@kjerneverk/riotplan-catalyst 1.0.0-dev.0 → 1.0.4

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,65 @@
+name: Node.js Package (npm)
+
+on:
+  release:
+    types: [created]
+  push:
+    branches:
+      - working
+
+permissions:
+  contents: write
+  packages: write
+  id-token: write
+
+jobs:
+  publish-npm:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org/
+      - name: Determine npm tag and publish strategy
+        id: npm-tag
+        run: |
+          VERSION=$(node -p "require('./package.json').version")
+          IS_RELEASE="${{ github.event_name == 'release' }}"
+          SHORT_SHA=$(git rev-parse --short=7 HEAD)
+          TIMESTAMP=$(date +%Y%m%d%H%M%S)
+
+          if [[ "$VERSION" == *"-"* ]]; then
+            echo "tag=dev" >> $GITHUB_OUTPUT
+            echo "should_publish=true" >> $GITHUB_OUTPUT
+            # Add timestamp and SHA to pre-release version (e.g., 1.5.5-dev.0 -> 1.5.5-dev.20260131210612.ab169e2)
+            BASE_VERSION="${VERSION%%-*}"
+            NEW_VERSION="${BASE_VERSION}-dev.${TIMESTAMP}.${SHORT_SHA}"
+            echo "version=${NEW_VERSION}" >> $GITHUB_OUTPUT
+            echo "📦 Publishing pre-release version: ${NEW_VERSION}"
+          else
+            echo "tag=latest" >> $GITHUB_OUTPUT
+            echo "version=${VERSION}" >> $GITHUB_OUTPUT
+            # Only publish production versions on release events
+            if [[ "$IS_RELEASE" == "true" ]]; then
+              echo "should_publish=true" >> $GITHUB_OUTPUT
+              echo "📦 Publishing production version: ${VERSION}"
+            else
+              echo "should_publish=false" >> $GITHUB_OUTPUT
+              echo "⚠️  Skipping publish: Production version detected on non-release push"
+            fi
+          fi
+      - run: npm install -g npm@latest
+        if: steps.npm-tag.outputs.should_publish == 'true'
+      - run: npm install --verbose --foreground-scripts
+        if: steps.npm-tag.outputs.should_publish == 'true'
+        timeout-minutes: 10
+      - name: Update package.json version for pre-release
+        if: steps.npm-tag.outputs.should_publish == 'true' && steps.npm-tag.outputs.tag == 'dev'
+        run: |
+          node -e "const pkg = require('./package.json'); pkg.version = '${{ steps.npm-tag.outputs.version }}'; require('fs').writeFileSync('./package.json', JSON.stringify(pkg, null, 2) + '\n');"
+          echo "Updated package.json to version ${{ steps.npm-tag.outputs.version }}"
+      - name: Publish to npm
+        if: steps.npm-tag.outputs.should_publish == 'true'
+        run: npm publish --access public --tag ${{ steps.npm-tag.outputs.tag }}

package/.github/workflows/test.yml

@@ -0,0 +1,42 @@
+name: Run Tests
+
+on:
+  push:
+    branches:
+      - main
+      - working
+      - 'release/**'
+      - 'feature/**'
+      - 'dependabot/**'
+  pull_request:
+    branches:
+      - main
+
+concurrency:
+  group: test-${{ github.head_ref || github.ref_name }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      - name: Install dependencies
+        run: |
+          # Use public npm registry (package-lock.json is gitignored)
+          npm config set registry https://registry.npmjs.org/
+          # Clean install to ensure platform-specific optional deps (rollup native bindings) are resolved correctly
+          # See: https://github.com/npm/cli/issues/4828
+          rm -rf node_modules package-lock.json
+          npm install --force
+        timeout-minutes: 10
+      - run: npm run lint
+      - run: npm run build
+      - run: npm run test

package/README.md

@@ -325,3 +325,6 @@ if (catalyst === null) {
 ## License
 
 Apache-2.0
+TEST
+TEST
+TEST

package/eslint.config.mjs

@@ -1,38 +1,85 @@
-import js from '@eslint/js';
-import ts from '@typescript-eslint/eslint-plugin';
-import tsParser from '@typescript-eslint/parser';
-import importPlugin from 'eslint-plugin-import';
-
-export default [
-  {
-    ignores: ['dist/**', 'node_modules/**', '**/*.test.ts', 'vitest.config.ts', 'vite.config.ts'],
-  },
-  {
-    files: ['**/*.ts'],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: 2024,
-        sourceType: 'module',
-      },
-      globals: {
-        console: 'readonly',
-        process: 'readonly',
-        NodeJS: 'readonly',
-      },
-    },
-    plugins: {
-      '@typescript-eslint': ts,
-      import: importPlugin,
-    },
-    rules: {
-      ...js.configs.recommended.rules,
-      ...ts.configs.recommended.rules,
-      indent: ['error', 2],
-      quotes: ['error', 'single'],
-      semi: ['error', 'always'],
-      'no-console': ['error', { allow: ['warn', 'error'] }],
-      'import/order': 'error',
+import { defineConfig, globalIgnores } from "eslint/config";
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import importPlugin from "eslint-plugin-import";
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+});
+
+export default defineConfig([
+    globalIgnores([
+        "dist/**",
+        "node_modules/**",
+        "**/*.test.ts",
+    ]),
+    {
+        extends: compat.extends("eslint:recommended", "plugin:@typescript-eslint/recommended"),
+
+        plugins: {
+            "@typescript-eslint": typescriptEslint,
+            "import": importPlugin,
+        },
+
+        languageOptions: {
+            globals: {
+                ...globals.node,
+            },
+
+            parser: tsParser,
+            ecmaVersion: "latest",
+            sourceType: "module",
+        },
+
+        rules: {
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/explicit-function-return-type": "off",
+
+            "@typescript-eslint/no-unused-vars": ["warn", {
+                argsIgnorePattern: "^_",
+            }],
+
+            indent: ["error", 4, {
+                SwitchCase: 1,
+            }],
+
+            "import/extensions": ["error", "ignorePackages", {
+                "js": "always",
+                "ts": "never"
+            }],
+
+            "import/no-extraneous-dependencies": ["error", {
+                devDependencies: true,
+                optionalDependencies: false,
+                peerDependencies: false,
+            }],
+
+            "no-console": ["error"],
+
+            "no-restricted-imports": ["error", {
+                paths: ["dayjs", "fs", "moment-timezone"],
+                patterns: [
+                    {
+                        group: ["src/**"],
+                        message: "Use absolute imports instead of relative imports"
+                    }
+                ]
+            }]
+        },
     },
-  },
-];
+    // Allow console in CLI files
+    {
+        files: ["src/cli/**/*.ts"],
+        rules: {
+            "no-console": "off",
+        },
+    }]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kjerneverk/riotplan-catalyst",
-  "version": "1.0.0-dev.0",
+  "version": "1.0.4",
   "description": "Catalyst system for RiotPlan - composable, layerable guidance packages for plan creation",
   "type": "module",
   "main": "./dist/riotplan-catalyst.js",
@@ -30,13 +30,15 @@
     "zod": "^3.23.0"
   },
   "devDependencies": {
-    "@rollup/plugin-replace": "^5.0.5",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.28.0",
     "@types/node": "^25.2.2",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.34.0",
+    "@typescript-eslint/parser": "^8.34.0",
     "@vitest/coverage-v8": "^1.1.0",
-    "eslint": "^8.56.0",
-    "eslint-plugin-import": "^2.29.0",
+    "eslint": "^9.28.0",
+    "eslint-plugin-import": "^2.31.0",
+    "globals": "^17.0.0",
     "typescript": "^5.4.0",
     "vite": "^5.1.0",
     "vite-plugin-dts": "^1.0.0",
@@ -50,5 +52,9 @@
     "ai"
   ],
   "author": "Kjerneverk",
-  "license": "Apache-2.0"
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kjerneverk/riotplan-catalyst"
+  }
 }

package/src/loader/catalyst-loader.ts

@@ -7,18 +7,18 @@ import { readFile, readdir, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { 
-  CatalystManifestSchema, 
-  FACET_DIRECTORIES,
-  type FacetType,
-} from '@/schema/schemas';
+    CatalystManifestSchema, 
+    FACET_DIRECTORIES,
+    type FacetType,
+} from '@/schema/schemas.js';
 import type { 
-  Catalyst, 
-  CatalystManifest, 
-  CatalystFacets, 
-  FacetContent,
-  CatalystLoadOptions,
-  CatalystLoadResult,
-} from '@/types';
+    Catalyst, 
+    CatalystManifest, 
+    CatalystFacets, 
+    FacetContent,
+    CatalystLoadOptions,
+    CatalystLoadResult,
+} from '@/types.js';
 
 /**
  * Load a catalyst manifest from catalyst.yml
@@ -27,29 +27,29 @@ import type {
  * @throws Error if manifest is missing or invalid
  */
 async function loadManifest(directoryPath: string): Promise<CatalystManifest> {
-  const manifestPath = join(directoryPath, 'catalyst.yml');
+    const manifestPath = join(directoryPath, 'catalyst.yml');
   
-  try {
-    const content = await readFile(manifestPath, 'utf-8');
-    const parsed = parseYaml(content);
+    try {
+        const content = await readFile(manifestPath, 'utf-8');
+        const parsed = parseYaml(content);
     
-    // Validate with Zod schema
-    const result = CatalystManifestSchema.safeParse(parsed);
+        // Validate with Zod schema
+        const result = CatalystManifestSchema.safeParse(parsed);
     
-    if (!result.success) {
-      const errors = result.error.issues.map(issue => 
-        `${issue.path.join('.')}: ${issue.message}`
-      ).join('; ');
-      throw new Error(`Invalid catalyst manifest: ${errors}`);
-    }
+        if (!result.success) {
+            const errors = result.error.issues.map(issue => 
+                `${issue.path.join('.')}: ${issue.message}`
+            ).join('; ');
+            throw new Error(`Invalid catalyst manifest: ${errors}`);
+        }
     
-    return result.data;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      throw new Error(`Catalyst manifest not found at ${manifestPath}`);
+        return result.data;
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+            throw new Error(`Catalyst manifest not found at ${manifestPath}`);
+        }
+        throw error;
     }
-    throw error;
-  }
 }
 
 /**
@@ -58,43 +58,43 @@ async function loadManifest(directoryPath: string): Promise<CatalystManifest> {
  * @returns Array of FacetContent objects
  */
 async function loadFacetFiles(facetPath: string): Promise<FacetContent[]> {
-  try {
-    const entries = await readdir(facetPath, { withFileTypes: true });
-    const markdownFiles = entries.filter(
-      entry => entry.isFile() && entry.name.endsWith('.md')
-    );
+    try {
+        const entries = await readdir(facetPath, { withFileTypes: true });
+        const markdownFiles = entries.filter(
+            entry => entry.isFile() && entry.name.endsWith('.md')
+        );
     
-    const contents = await Promise.all(
-      markdownFiles.map(async (file) => {
-        const filePath = join(facetPath, file.name);
-        const content = await readFile(filePath, 'utf-8');
-        return {
-          filename: file.name,
-          content,
-        };
-      })
-    );
+        const contents = await Promise.all(
+            markdownFiles.map(async (file) => {
+                const filePath = join(facetPath, file.name);
+                const content = await readFile(filePath, 'utf-8');
+                return {
+                    filename: file.name,
+                    content,
+                };
+            })
+        );
     
-    return contents;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      // Directory doesn't exist - return empty array
-      return [];
+        return contents;
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+            // Directory doesn't exist - return empty array
+            return [];
+        }
+        throw error;
     }
-    throw error;
-  }
 }
 
 /**
  * Check if a directory exists
  */
 async function directoryExists(path: string): Promise<boolean> {
-  try {
-    const stats = await stat(path);
-    return stats.isDirectory();
-  } catch {
-    return false;
-  }
+    try {
+        const stats = await stat(path);
+        return stats.isDirectory();
+    } catch {
+        return false;
+    }
 }
 
 /**
@@ -105,46 +105,46 @@ async function directoryExists(path: string): Promise<boolean> {
  * @returns Loaded facets and any warnings
  */
 async function loadFacets(
-  directoryPath: string,
-  manifest: CatalystManifest,
-  options: CatalystLoadOptions = {}
+    directoryPath: string,
+    manifest: CatalystManifest,
+    options: CatalystLoadOptions = {}
 ): Promise<{ facets: CatalystFacets; warnings: string[] }> {
-  const facets: CatalystFacets = {};
-  const warnings: string[] = [];
+    const facets: CatalystFacets = {};
+    const warnings: string[] = [];
   
-  // Load each facet type
-  for (const [facetKey, dirName] of Object.entries(FACET_DIRECTORIES)) {
-    const facetType = facetKey as FacetType;
-    const facetPath = join(directoryPath, dirName);
-    const exists = await directoryExists(facetPath);
+    // Load each facet type
+    for (const [facetKey, dirName] of Object.entries(FACET_DIRECTORIES)) {
+        const facetType = facetKey as FacetType;
+        const facetPath = join(directoryPath, dirName);
+        const exists = await directoryExists(facetPath);
     
-    // Check if facet is declared in manifest
-    const declared = manifest.facets?.[facetType];
+        // Check if facet is declared in manifest
+        const declared = manifest.facets?.[facetType];
     
-    if (exists) {
-      // Load the facet content
-      const content = await loadFacetFiles(facetPath);
-      if (content.length > 0) {
-        facets[facetType] = content;
-      }
+        if (exists) {
+            // Load the facet content
+            const content = await loadFacetFiles(facetPath);
+            if (content.length > 0) {
+                facets[facetType] = content;
+            }
       
-      // Warn if present but explicitly declared as false
-      if (declared === false && options.warnOnUndeclaredFacets) {
-        warnings.push(
-          `Facet '${facetType}' is present but declared as false in manifest`
-        );
-      }
-    } else {
-      // Warn if declared but missing
-      if (declared === true && options.warnOnMissingFacets) {
-        warnings.push(
-          `Facet '${facetType}' is declared in manifest but directory '${dirName}' not found`
-        );
-      }
+            // Warn if present but explicitly declared as false
+            if (declared === false && options.warnOnUndeclaredFacets) {
+                warnings.push(
+                    `Facet '${facetType}' is present but declared as false in manifest`
+                );
+            }
+        } else {
+            // Warn if declared but missing
+            if (declared === true && options.warnOnMissingFacets) {
+                warnings.push(
+                    `Facet '${facetType}' is declared in manifest but directory '${dirName}' not found`
+                );
+            }
+        }
     }
-  }
   
-  return { facets, warnings };
+    return { facets, warnings };
 }
 
 /**
@@ -166,35 +166,36 @@ async function loadFacets(
  * ```
  */
 export async function loadCatalyst(
-  directoryPath: string,
-  options: CatalystLoadOptions = {}
+    directoryPath: string,
+    options: CatalystLoadOptions = {}
 ): Promise<Catalyst> {
-  // Resolve to absolute path
-  const absolutePath = resolve(directoryPath);
+    // Resolve to absolute path
+    const absolutePath = resolve(directoryPath);
   
-  // Check if directory exists
-  if (!await directoryExists(absolutePath)) {
-    throw new Error(`Catalyst directory not found: ${absolutePath}`);
-  }
+    // Check if directory exists
+    if (!await directoryExists(absolutePath)) {
+        throw new Error(`Catalyst directory not found: ${absolutePath}`);
+    }
   
-  // Load and validate manifest
-  const manifest = await loadManifest(absolutePath);
+    // Load and validate manifest
+    const manifest = await loadManifest(absolutePath);
   
-  // Load all facets
-  const { facets, warnings } = await loadFacets(absolutePath, manifest, options);
+    // Load all facets
+    const { facets, warnings } = await loadFacets(absolutePath, manifest, options);
   
-  // Log warnings if any
-  if (warnings.length > 0 && !options.strict) {
-    for (const warning of warnings) {
-      console.warn(`[catalyst-loader] ${warning}`);
+    // Log warnings if any
+    if (warnings.length > 0 && !options.strict) {
+        for (const warning of warnings) {
+            // eslint-disable-next-line no-console
+            console.warn(`[catalyst-loader] ${warning}`);
+        }
     }
-  }
   
-  return {
-    manifest,
-    facets,
-    directoryPath: absolutePath,
-  };
+    return {
+        manifest,
+        facets,
+        directoryPath: absolutePath,
+    };
 }
 
 /**
@@ -207,21 +208,21 @@ export async function loadCatalyst(
  * @returns Result object with success/error
  */
 export async function loadCatalystSafe(
-  directoryPath: string,
-  options: CatalystLoadOptions = {}
+    directoryPath: string,
+    options: CatalystLoadOptions = {}
 ): Promise<CatalystLoadResult> {
-  try {
-    const catalyst = await loadCatalyst(directoryPath, options);
-    return {
-      success: true,
-      catalyst,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
+    try {
+        const catalyst = await loadCatalyst(directoryPath, options);
+        return {
+            success: true,
+            catalyst,
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
 }
 
 /**
@@ -236,26 +237,26 @@ export async function loadCatalystSafe(
  * @returns Array of loaded catalysts
  */
 export async function resolveCatalysts(
-  identifiers: string[],
-  basePath: string = process.cwd(),
-  options: CatalystLoadOptions = {}
+    identifiers: string[],
+    basePath: string = process.cwd(),
+    options: CatalystLoadOptions = {}
 ): Promise<Catalyst[]> {
-  const catalysts: Catalyst[] = [];
+    const catalysts: Catalyst[] = [];
   
-  for (const identifier of identifiers) {
+    for (const identifier of identifiers) {
     // Phase 1: treat identifier as a path
     // If it's relative, resolve from basePath
-    const path = resolve(basePath, identifier);
+        const path = resolve(basePath, identifier);
     
-    try {
-      const catalyst = await loadCatalyst(path, options);
-      catalysts.push(catalyst);
-    } catch (error) {
-      throw new Error(
-        `Failed to load catalyst '${identifier}': ${error instanceof Error ? error.message : String(error)}`
-      );
+        try {
+            const catalyst = await loadCatalyst(path, options);
+            catalysts.push(catalyst);
+        } catch (error) {
+            throw new Error(
+                `Failed to load catalyst '${identifier}': ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
     }
-  }
   
-  return catalysts;
+    return catalysts;
 }