create-portfoliable 1.0.3

package/templates/scripts/convert-wav-to-mp3.mjs

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+// File: templates/scripts/convert-wav-to-mp3.mjs
+// Purpose: Convert WAV files to MP3 and write outputs beside original files.
+// Author: Lio Schimanko
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const SKIPPED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist']);
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const options = {
+    dir: process.cwd(),
+    force: false,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+
+    if ((token === '--dir' || token === '--input') && args[i + 1]) {
+      options.dir = path.resolve(String(args[i + 1]));
+      i += 1;
+      continue;
+    }
+
+    if (token === '--force') {
+      options.force = true;
+      continue;
+    }
+
+    if (token === '--help' || token === '-h') {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  console.log('Usage: npm run convert:audio -- [--dir <path>] [--force]');
+  console.log('');
+  console.log('Options:');
+  console.log('  --dir, --input  Root directory to scan recursively for .wav files');
+  console.log('  --force         Overwrite existing .mp3 targets');
+  console.log('  --help, -h      Show help');
+}
+
+function verifyFfmpeg() {
+  const result = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });
+  if (result.error || result.status !== 0) {
+    throw new Error('ffmpeg is required. Install it first (for macOS: brew install ffmpeg).');
+  }
+}
+
+function collectWavFiles(rootDir, output = []) {
+  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const absolutePath = path.join(rootDir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (SKIPPED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      collectWavFiles(absolutePath, output);
+      continue;
+    }
+
+    if (entry.isFile() && path.extname(entry.name).toLowerCase() === '.wav') {
+      output.push(absolutePath);
+    }
+  }
+
+  return output;
+}
+
+function convertOneFile(inputPath, force = false) {
+  const directory = path.dirname(inputPath);
+  const baseName = path.basename(inputPath, path.extname(inputPath));
+  const outputPath = path.join(directory, `${baseName}.mp3`);
+
+  if (fs.existsSync(outputPath) && !force) {
+    return {
+      status: 'skipped',
+      inputPath,
+      outputPath,
+      reason: 'target exists'
+    };
+  }
+
+  const ffmpegArgs = [
+    '-hide_banner',
+    '-loglevel',
+    'error',
+    force ? '-y' : '-n',
+    '-i',
+    inputPath,
+    '-codec:a',
+    'libmp3lame',
+    '-q:a',
+    '2',
+    outputPath
+  ];
+
+  const result = spawnSync('ffmpeg', ffmpegArgs, {
+    encoding: 'utf8'
+  });
+
+  if (result.error || result.status !== 0) {
+    return {
+      status: 'failed',
+      inputPath,
+      outputPath,
+      reason: (result.stderr || result.error?.message || 'conversion failed').trim()
+    };
+  }
+
+  return {
+    status: 'converted',
+    inputPath,
+    outputPath
+  };
+}
+
+function main() {
+  const options = parseArgs(process.argv);
+
+  if (options.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (!fs.existsSync(options.dir) || !fs.statSync(options.dir).isDirectory()) {
+    console.error(`[convert:audio] Invalid directory: ${options.dir}`);
+    process.exit(1);
+  }
+
+  verifyFfmpeg();
+
+  const wavFiles = collectWavFiles(options.dir);
+  if (wavFiles.length === 0) {
+    console.log(`[convert:audio] No WAV files found under ${options.dir}`);
+    process.exit(0);
+  }
+
+  let converted = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const inputPath of wavFiles) {
+    const result = convertOneFile(inputPath, options.force);
+
+    if (result.status === 'converted') {
+      converted += 1;
+      console.log(`[convert:audio] Converted: ${result.outputPath}`);
+      continue;
+    }
+
+    if (result.status === 'skipped') {
+      skipped += 1;
+      console.log(`[convert:audio] Skipped: ${result.outputPath} (${result.reason})`);
+      continue;
+    }
+
+    failed += 1;
+    console.error(`[convert:audio] Failed: ${result.inputPath}`);
+    console.error(`[convert:audio] Reason: ${result.reason}`);
+  }
+
+  console.log(`[convert:audio] Done. converted=${converted} skipped=${skipped} failed=${failed}`);
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[convert:audio] ${error?.message || String(error)}`);
+  process.exit(1);
+}

package/templates/scripts/delete-case.mjs

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+// File: scripts/delete-case.mjs
+// Purpose: Remove a generated case from src/content/cases by id or explicit file path.
+// Author: Lio Schimanko
+
+// MARK: IMPORTS
+import fs from 'node:fs';
+import path from 'node:path';
+
+// MARK: CASE ROOTS
+const DEFAULT_CASES_ROOTS = ['src/content/cases', 'templates/src/content/cases'];
+
+// MARK: ARGUMENT PARSING
+// Parses CLI flags for case id, explicit output path, and force deletion mode.
+function parseArgs(argv) {
+  const parsed = {
+    id: '',
+    outFile: '',
+    force: false
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === '--id') {
+      parsed.id = String(argv[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+
+    if (token === '--out') {
+      parsed.outFile = String(argv[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+
+    if (token === '--force') {
+      parsed.force = true;
+    }
+  }
+
+  return parsed;
+}
+
+// Normalizes case identifiers into kebab-case slugs.
+function toSlug(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+// MARK: CASE DISCOVERY HELPERS
+// Recursively lists files under a root directory.
+function walkFilesRecursive(rootDir) {
+  const files = [];
+
+  // Traverses nested directories and appends discovered files.
+  const visit = (currentDir) => {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        visit(absolutePath);
+        continue;
+      }
+      files.push(absolutePath);
+    }
+  };
+
+  visit(rootDir);
+  return files;
+}
+
+// Deduplicates candidate file paths using absolute path normalization.
+function uniquePaths(paths) {
+  return [...new Set(paths.map((candidate) => path.resolve(candidate)))];
+}
+
+// Resolves existing case roots in both consumer and template layouts.
+function resolveCasesRoots(cwd) {
+  return DEFAULT_CASES_ROOTS
+    .map((relativeRoot) => path.resolve(cwd, relativeRoot))
+    .filter((absoluteRoot) => fs.existsSync(absoluteRoot) && fs.statSync(absoluteRoot).isDirectory());
+}
+
+// Generates direct candidate markdown paths for a case identifier.
+function resolveIdCandidates(cwd, caseId) {
+  const roots = resolveCasesRoots(cwd);
+  const directCandidates = [];
+
+  for (const casesRoot of roots) {
+    directCandidates.push(path.resolve(casesRoot, caseId, 'case.md'));
+    directCandidates.push(path.resolve(casesRoot, `${caseId}.md`));
+    directCandidates.push(path.resolve(casesRoot, 'summary', caseId, 'case.md'));
+    directCandidates.push(path.resolve(casesRoot, 'summary', `${caseId}.md`));
+    directCandidates.push(path.resolve(casesRoot, 'reader', caseId, 'case.md'));
+    directCandidates.push(path.resolve(casesRoot, 'reader', `${caseId}.md`));
+  }
+
+  return uniquePaths(directCandidates);
+}
+
+// Searches case roots for matching case filenames and nested case.md folders.
+function searchCaseMatches(cwd, caseId) {
+  const roots = resolveCasesRoots(cwd);
+  const expectedMarkdownName = `${caseId}.md`;
+  const matches = [];
+
+  for (const casesRoot of roots) {
+    const files = walkFilesRecursive(casesRoot).filter((candidate) => candidate.endsWith('.md'));
+    for (const filePath of files) {
+      if (path.basename(filePath) === expectedMarkdownName) {
+        matches.push(filePath);
+        continue;
+      }
+
+      if (path.basename(filePath) === 'case.md' && path.basename(path.dirname(filePath)) === caseId) {
+        matches.push(filePath);
+      }
+    }
+  }
+
+  return uniquePaths(matches);
+}
+
+// Collects known case ids to suggest alternatives when a delete target is missing.
+function collectKnownCaseIds(cwd) {
+  const roots = resolveCasesRoots(cwd);
+  const ids = new Set();
+
+  for (const casesRoot of roots) {
+    const files = walkFilesRecursive(casesRoot).filter((candidate) => candidate.endsWith('.md'));
+    for (const filePath of files) {
+      const baseName = path.basename(filePath);
+      if (baseName === 'case.md') {
+        ids.add(path.basename(path.dirname(filePath)));
+        continue;
+      }
+
+      ids.add(path.basename(filePath, '.md'));
+    }
+  }
+
+  return [...ids].sort((a, b) => a.localeCompare(b));
+}
+
+// Suggests nearby case ids using contains/token overlap matching.
+function suggestCaseIds(knownIds, missingId) {
+  const needle = String(missingId || '').trim().toLowerCase();
+  if (!needle) return [];
+
+  const tokens = needle.split('-').filter(Boolean);
+  const matches = knownIds.filter((candidate) => {
+    const lower = candidate.toLowerCase();
+    if (lower.includes(needle) || needle.includes(lower)) {
+      return true;
+    }
+
+    const hitCount = tokens.filter((token) => lower.includes(token)).length;
+    return hitCount >= Math.max(1, Math.min(2, tokens.length));
+  });
+
+  return matches.slice(0, 8);
+}
+
+// Resolves deletion candidates from explicit output path or computed case id lookups.
+function resolveCaseCandidates(cwd, options) {
+  if (options.outFile) {
+    return [path.resolve(cwd, options.outFile)];
+  }
+
+  const caseId = toSlug(options.caseId);
+  if (!caseId) {
+    throw new Error('Missing case target. Use --id <case-slug> or --out <path>.');
+  }
+
+  const directCandidates = resolveIdCandidates(cwd, caseId);
+  const directExisting = directCandidates.filter((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+  if (directExisting.length > 0) {
+    return directExisting;
+  }
+
+  const searched = searchCaseMatches(cwd, caseId);
+  if (searched.length > 0) {
+    return searched;
+  }
+
+  return directCandidates;
+}
+
+// Returns the first candidate path that currently exists on disk.
+function firstExistingPath(candidates) {
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+// Detects nested case folder format where file is case.md.
+function isNestedCaseFile(filePath) {
+  return path.basename(filePath) === 'case.md';
+}
+
+// Removes now-empty parent case directory when safe to do so.
+function removeEmptyParentDirectory(filePath, rootPath) {
+  const parentDir = path.dirname(filePath);
+  if (path.resolve(parentDir) === path.resolve(rootPath)) {
+    return;
+  }
+
+  const entries = fs.readdirSync(parentDir);
+  if (entries.length === 0) {
+    fs.rmdirSync(parentDir);
+  }
+}
+
+// MARK: CASE DELETION WORKFLOW
+// Deletes a case markdown file (or full case directory in force mode) with diagnostics.
+export function runDeleteCase(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const force = options.force === true;
+  const requestedCaseId = toSlug(options.caseId);
+  const candidates = resolveCaseCandidates(cwd, options);
+  const existingCandidates = candidates.filter((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+
+  if (existingCandidates.length > 1 && !options.outFile) {
+    throw new Error(`Multiple case matches found for --id ${String(options.caseId || '')}. Use --out with one of: ${existingCandidates.join(', ')}`);
+  }
+
+  const targetPath = firstExistingPath(candidates);
+
+  if (!targetPath) {
+    const knownIds = collectKnownCaseIds(cwd);
+    const suggestedIds = suggestCaseIds(knownIds, requestedCaseId);
+    return {
+      removedPath: '',
+      removedDirectory: false,
+      removedDirectoryPath: '',
+      alreadyMissing: true,
+      checkedCandidates: candidates,
+      requestedCaseId,
+      suggestedIds
+    };
+  }
+
+  const casesRoots = resolveCasesRoots(cwd);
+  const absoluteCasesRoot = casesRoots.find((rootPath) => targetPath.startsWith(`${rootPath}${path.sep}`)) || path.dirname(targetPath);
+
+  if (isNestedCaseFile(targetPath)) {
+    const caseDir = path.dirname(targetPath);
+    const siblingEntries = fs.readdirSync(caseDir).filter((entry) => entry !== 'case.md');
+
+    if (siblingEntries.length > 0 && !force) {
+      throw new Error(`Case directory ${caseDir} has additional files. Re-run with --force to remove the full case directory.`);
+    }
+
+    if (siblingEntries.length > 0 && force) {
+      fs.rmSync(caseDir, { recursive: true, force: false });
+      return {
+        removedPath: targetPath,
+        removedDirectory: true,
+        removedDirectoryPath: caseDir,
+        alreadyMissing: false,
+        checkedCandidates: [],
+        requestedCaseId,
+        suggestedIds: []
+      };
+    }
+
+    fs.rmSync(targetPath);
+    removeEmptyParentDirectory(targetPath, absoluteCasesRoot);
+    return {
+      removedPath: targetPath,
+      removedDirectory: false,
+      removedDirectoryPath: '',
+      alreadyMissing: false,
+      checkedCandidates: [],
+      requestedCaseId,
+      suggestedIds: []
+    };
+  }
+
+  fs.rmSync(targetPath);
+  return {
+    removedPath: targetPath,
+    removedDirectory: false,
+    removedDirectoryPath: '',
+    alreadyMissing: false,
+    checkedCandidates: [],
+    requestedCaseId,
+    suggestedIds: []
+  };
+}
+
+// MARK: SCRIPT ENTRYPOINT
+// CLI entrypoint for delete-case script usage.
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = parseArgs(process.argv.slice(2));
+  try {
+    const result = runDeleteCase({ caseId: args.id, outFile: args.outFile, force: args.force });
+    if (result.alreadyMissing) {
+      console.log('[delete-case] Nothing to delete. Target is already missing.');
+      if (result.suggestedIds.length > 0) {
+        console.log(`[delete-case] Similar existing case ids: ${result.suggestedIds.join(', ')}`);
+      }
+    } else {
+      console.log(`[delete-case] Removed ${result.removedPath}.`);
+      if (result.removedDirectory) {
+        console.log(`[delete-case] Removed case directory ${result.removedDirectoryPath}.`);
+      }
+    }
+  } catch (error) {
+    console.error('[delete-case] Failed:', error.message || error);
+    process.exit(1);
+  }
+}

package/templates/scripts/delete-language.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+// File: scripts/delete-language.mjs
+// Purpose: Remove a locale from i18n config and prune locale entries from labels/about/cases.
+// Author: Lio Schimanko
+
+// MARK: IMPORTS
+import fs from 'node:fs';
+import { resolveI18nConfigPath } from './i18n-config-utils.mjs';
+import { runLocaleSync } from './sync-locales.mjs';
+
+// MARK: CONFIG PATTERNS
+const LANGUAGE_CONFIG_REGEX = /export\s+const\s+LANGUAGE_CONFIG\s*=\s*Object\.freeze\(\s*(\{[\s\S]*?\})\s*\);/;
+const DEFAULT_LOCALE_REGEX = /export\s+const\s+DEFAULT_LOCALE\s*=\s*['\"]([^'\"]+)['\"]/;
+const RTL_LOCALE_CODES_REGEX = /export\s+const\s+RTL_LOCALE_CODES\s*=\s*Object\.freeze\(\s*(\[[\s\S]*?\])\s*\);/;
+
+// MARK: ARGUMENT AND LITERAL PARSING
+// Parses object-like config literals using JSON first with JS-literal fallback.
+function parseConfigLiteral(literalText, fallbackValue = null) {
+  const raw = String(literalText || '').trim();
+  if (!raw) return fallbackValue;
+
+  try {
+    return JSON.parse(raw);
+  } catch {
+    try {
+      const evaluateLiteral = new Function(`return (${raw});`);
+      return evaluateLiteral();
+    } catch {
+      return fallbackValue;
+    }
+  }
+}
+
+// Parses delete-language CLI arguments and optional force mode.
+function parseArgs(argv) {
+  const parsed = {
+    code: '',
+    force: false
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === '--code') {
+      parsed.code = String(argv[i + 1] || '').trim().toLowerCase();
+      i += 1;
+      continue;
+    }
+
+    if (token === '--force') {
+      parsed.force = true;
+      continue;
+    }
+  }
+
+  return parsed;
+}
+
+// Validates locale identifier format before deleting entries.
+function validateLocaleCode(localeCode) {
+  return /^[a-z]{2,3}(?:-[a-z0-9]+)*$/i.test(String(localeCode || '').trim());
+}
+
+// Rewrites DEFAULT_LOCALE export when deleting the active default locale.
+function replaceDefaultLocale(source, nextDefaultLocale) {
+  if (!DEFAULT_LOCALE_REGEX.test(source)) {
+    return source;
+  }
+
+  return source.replace(DEFAULT_LOCALE_REGEX, `export const DEFAULT_LOCALE = '${nextDefaultLocale}'`);
+}
+
+// MARK: LANGUAGE REMOVAL WORKFLOW
+// Removes one locale from i18n config and syncs locale-bound content maps.
+export async function runDeleteLanguage(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const localeCode = String(options.code || '').trim().toLowerCase();
+
+  if (!validateLocaleCode(localeCode)) {
+    throw new Error('Invalid locale code. Use values like "it", "es", or "pt-BR".');
+  }
+
+  const i18nConfigPath = resolveI18nConfigPath(cwd);
+  if (!fs.existsSync(i18nConfigPath)) {
+    throw new Error(`Could not find i18n config file at ${i18nConfigPath}`);
+  }
+
+  const source = fs.readFileSync(i18nConfigPath, 'utf8');
+  const languageConfigMatch = source.match(LANGUAGE_CONFIG_REGEX);
+  if (!languageConfigMatch?.[1]) {
+    throw new Error(`LANGUAGE_CONFIG block was not found in ${i18nConfigPath}`);
+  }
+
+  const defaultLocaleMatch = source.match(DEFAULT_LOCALE_REGEX);
+  const currentDefaultLocale = String(defaultLocaleMatch?.[1] || 'en').trim().toLowerCase();
+
+  let languageConfig = {};
+  let rtlLocaleCodes = [];
+  languageConfig = parseConfigLiteral(languageConfigMatch[1], null);
+  if (!languageConfig || typeof languageConfig !== 'object' || Array.isArray(languageConfig)) {
+    throw new Error(`LANGUAGE_CONFIG is not valid JSON in ${i18nConfigPath}`);
+  }
+
+  const rtlLocaleCodesMatch = source.match(RTL_LOCALE_CODES_REGEX);
+  if (rtlLocaleCodesMatch?.[1]) {
+    const parsed = parseConfigLiteral(rtlLocaleCodesMatch[1], null);
+    if (Array.isArray(parsed)) {
+      rtlLocaleCodes = parsed;
+    } else {
+      throw new Error(`RTL_LOCALE_CODES is not valid JSON in ${i18nConfigPath}`);
+    }
+  }
+
+  if (!languageConfig[localeCode]) {
+    return {
+      removedLocale: localeCode,
+      defaultLocaleBefore: currentDefaultLocale,
+      defaultLocaleAfter: currentDefaultLocale,
+      i18nConfigPath,
+      localeCodes: Object.keys(languageConfig),
+      syncResult: { updatedFiles: 0, localeCodes: Object.keys(languageConfig) },
+      alreadyMissing: true
+    };
+  }
+
+  if (localeCode === currentDefaultLocale && options.force !== true) {
+    throw new Error(`Locale ${localeCode} is the DEFAULT_LOCALE. Use --force to remove it and reassign default locale.`);
+  }
+
+  const nextLanguageConfig = { ...languageConfig };
+  delete nextLanguageConfig[localeCode];
+
+  const remainingLocales = Object.keys(nextLanguageConfig);
+  if (remainingLocales.length === 0) {
+    throw new Error('Cannot remove the last remaining locale.');
+  }
+
+  const nextDefaultLocale = localeCode === currentDefaultLocale
+    ? remainingLocales[0]
+    : currentDefaultLocale;
+
+  const nextLanguageConfigBlock = `export const LANGUAGE_CONFIG = Object.freeze(${JSON.stringify(nextLanguageConfig, null, 2)});`;
+  let nextSource = source.replace(LANGUAGE_CONFIG_REGEX, nextLanguageConfigBlock);
+  const nextRtlLocaleCodes = rtlLocaleCodes
+    .map((value) => String(value || '').trim().toLowerCase())
+    .filter((value, index, list) => value.length > 0 && list.indexOf(value) === index)
+    .filter((value) => value !== localeCode)
+    .sort((a, b) => a.localeCompare(b));
+  if (RTL_LOCALE_CODES_REGEX.test(nextSource)) {
+    const rtlBlock = `export const RTL_LOCALE_CODES = Object.freeze(${JSON.stringify(nextRtlLocaleCodes, null, 2)});`;
+    nextSource = nextSource.replace(RTL_LOCALE_CODES_REGEX, rtlBlock);
+  }
+  nextSource = replaceDefaultLocale(nextSource, nextDefaultLocale);
+
+  if (nextSource !== source) {
+    fs.writeFileSync(i18nConfigPath, nextSource, 'utf8');
+  }
+
+  const syncResult = await runLocaleSync({
+    cwd,
+    pruneLocales: true
+  });
+
+  return {
+    removedLocale: localeCode,
+    defaultLocaleBefore: currentDefaultLocale,
+    defaultLocaleAfter: nextDefaultLocale,
+    i18nConfigPath,
+    localeCodes: remainingLocales,
+    syncResult,
+    alreadyMissing: false
+  };
+}
+
+// MARK: SCRIPT ENTRYPOINT
+// CLI entrypoint for delete-language script usage.
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = parseArgs(process.argv.slice(2));
+
+  runDeleteLanguage(args)
+    .then((result) => {
+      if (result.alreadyMissing) {
+        console.log(`[delete-language] Nothing to delete. Locale ${result.removedLocale} is already missing.`);
+        return;
+      }
+      console.log(`[delete-language] Removed ${result.removedLocale}.`);
+      console.log(`[delete-language] Default locale: ${result.defaultLocaleBefore} -> ${result.defaultLocaleAfter}`);
+      console.log(`[delete-language] Locales: ${result.localeCodes.join(', ')}`);
+      console.log(`[delete-language] Synced ${result.syncResult.updatedFiles} file(s).`);
+    })
+    .catch((error) => {
+      console.error('[delete-language] Failed:', error.message || error);
+      process.exit(1);
+    });
+}