i18n-smell-detector 0.2.0 → 0.4.0

package/README.md

@@ -6,11 +6,12 @@
 
 Find locale values copied from the base locale.
 
-`i18n-smell-detector` checks localization files for keys whose translated value is identical to the base locale. This can help catch entries that were copied as placeholders and never translated.
+`i18n-smell-detector` checks localization files for keys whose translated value is identical to the base locale. It can also scan Vue templates for hardcoded user-visible strings.
 
 ## Features
 
 - Detect values that are identical to the base locale
+- Detect hardcoded strings in Vue template text and selected attributes
 - Ignore expected matches by key or value
 - Classify findings as `high`, `medium`, `low`, or `ignored`
 - Output results as console text, JSON, or Markdown
@@ -27,7 +28,9 @@ npm install -D i18n-smell-detector
 Run the check:
 
 ```bash
+npx i18n-smell-detector check --config i18n-smell.config.mjs
 npx i18n-smell-detector check-identical --config i18n-smell.config.mjs
+npx i18n-smell-detector check-hardcoded --config i18n-smell.config.mjs
 ```
 
 Output formats:
@@ -36,20 +39,83 @@ Output formats:
 npx i18n-smell-detector check-identical --format console
 npx i18n-smell-detector check-identical --format json
 npx i18n-smell-detector check-identical --format markdown
+npx i18n-smell-detector check-hardcoded --format json
+npx i18n-smell-detector check --format markdown --output i18n-report.md
 ```
 
+CLI options:
+
+| Option | Description |
+|---|---|
+| `-c, --config <path>` | Use a specific config file. |
+| `--format <format>` | Print `console`, `json`, or `markdown` output. |
+| `--fail-on <level>` | Exit with code `1` for findings at `high`, `medium`, or `low`. Use `none` while tuning. |
+| `--include-ignored` | Include ignored findings in the report. |
+| `--output <path>` | Write the full report to a file and print a short summary. |
+| `--baseline <path>` | Suppress findings stored in a baseline file. |
+| `--update-baseline` | Write the current findings to the baseline file. |
+| `-h, --help` | Show CLI help. |
+
 ## CI usage
 
 Use `--fail-on` to choose the lowest severity that should make the command exit with code `1`.
 
 ```bash
-npx i18n-smell-detector check-identical --config i18n-smell.config.mjs --fail-on high
+npx i18n-smell-detector check --config i18n-smell.config.mjs --fail-on high
 ```
 
 For a new project, it is often easier to start in reporting mode while tuning allowlists:
 
 ```bash
-npx i18n-smell-detector check-identical --config i18n-smell.config.mjs --fail-on none
+npx i18n-smell-detector check --config i18n-smell.config.mjs --fail-on none
+```
+
+### GitHub Actions example
+
+Add a workflow such as `.github/workflows/i18n-smell.yml`:
+
+```yaml
+name: i18n smell check
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  i18n-smell:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+
+      - run: npm ci
+
+      - name: Run i18n checks
+        run: npx i18n-smell-detector check --config i18n-smell.config.mjs --fail-on high
+
+      - name: Write Markdown report
+        if: always()
+        run: npx i18n-smell-detector check --config i18n-smell.config.mjs --format markdown --output reports/i18n-smell.md --fail-on none
+
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: i18n-smell-report
+          path: reports/i18n-smell.md
+```
+
+For this repository, the local smoke commands are:
+
+```bash
+npm test
+npm run check
+npm run example:basic
+node bin/i18n-smell-detector.js --help
 ```
 
 ## Configuration
@@ -59,6 +125,14 @@ Create `i18n-smell.config.mjs`:
 ```js
 export default {
   baseLocale: 'en',
+  checks: {
+    identical: true,
+    hardcoded: true
+  },
+  source: [
+    'src/**/*.vue'
+  ],
+
   locales: {
     en: './src/locales/en.json',
     zh: './src/locales/zh.json',
@@ -90,10 +164,28 @@ export default {
   ],
 
   ignoreCodeLike: true,
+  hardcoded: {
+    vueAttributes: [
+      'placeholder',
+      'title',
+      'alt',
+      'aria-label',
+      'aria-description'
+    ],
+    ignoreValues: [
+      'OK',
+      'ID'
+    ],
+    ignorePatterns: [
+      '^v\\d+$'
+    ]
+  },
   ignoreSameLanguageFamily: true,
   trimWhitespace: true,
   ignoreCase: false,
   includeIgnored: false,
+  format: 'console',
+  baseline: '.i18n-smell-baseline.json',
   failOn: 'high'
 };
 ```
@@ -103,16 +195,24 @@ export default {
 | Option | Type | Default | Description |
 |---|---|---:|---|
 | `baseLocale` | `string` | `'en'` | Locale used as the comparison source. It must also be listed in `locales`. |
+| `checks` | `{ identical?: boolean, hardcoded?: boolean }` | both enabled | Checks run by the combined `check` command. Existing single-check commands ignore this setting. |
+| `source` | `string[]` | `['src/**/*.vue']` | Source globs used by `check-hardcoded`. `node_modules` is ignored. |
 | `locales` | `Record<string, string>` | `{}` | Map of locale codes to JSON locale file paths. Relative paths are resolved from the config file directory. |
 | `allowIdenticalKeys` | `(string \| RegExp)[]` | `[]` | Key rules that are allowed to match the base locale. String rules support `*` wildcards, for example `brand.*`. `RegExp` rules are tested against the flattened key. |
 | `allowIdenticalValues` | `(string \| RegExp)[]` | `[]` | Value rules that are allowed to match the base locale. String rules are exact matches, for example `OK`, `API`, or `GET`. `RegExp` rules are tested against the full value. |
 | `placeholderPatterns` | `(string \| RegExp)[]` | `{...}` and `{{...}}` patterns | Placeholder patterns ignored when the whole value is only placeholders and whitespace. String entries must be valid regular expression sources. |
 | `ignoreCodeLike` | `boolean` | `true` | Ignore built-in code-like values such as paths, colors, acronyms, and identifiers. Set to `false` to report them. |
+| `hardcoded.vueAttributes` | `string[]` | `placeholder`, `title`, `alt`, `aria-label`, `aria-description` | Static Vue attributes checked by `check-hardcoded`. Dynamic bindings such as `:placeholder` are ignored. |
+| `hardcoded.ignoreValues` | `(string \| RegExp)[]` | `[]` | Exact values or regular expressions ignored by `check-hardcoded`. |
+| `hardcoded.ignorePatterns` | `(string \| RegExp)[]` | `[]` | Regular expression patterns ignored by `check-hardcoded`. String entries are compiled as regular expressions. |
 | `failOn` | `'high' \| 'medium' \| 'low' \| 'none'` | `'high'` | Lowest severity that makes the CLI exit with code `1`. Use `none` to report without failing. |
 | `trimWhitespace` | `boolean` | `true` | Trim leading and trailing whitespace before comparing values. |
 | `ignoreCase` | `boolean` | `false` | Compare values case-insensitively when set to `true`. |
 | `ignoreSameLanguageFamily` | `boolean` | `true` | Ignore regional variants that share the same language family, such as `en` and `en-GB`. Set to `false` to check regional variants too. |
 | `includeIgnored` | `boolean` | `false` | Include ignored findings in reports. Can also be enabled with `--include-ignored`. |
+| `format` | `'console' \| 'json' \| 'markdown'` | `'console'` | Default report format. CLI `--format` takes precedence. |
+| `output` | `string` | unset | Report file path. CLI `--output` takes precedence. |
+| `baseline` | `string` | unset | Baseline file path used by `--baseline` or `--update-baseline`. |
 
 ## Example output
 
@@ -173,6 +273,110 @@ Summary counts include all findings, including ignored findings that may be omit
 
 Ignored issues are omitted by default. Pass `--include-ignored` to include them in JSON, console, or Markdown output.
 
+## Hardcoded string output
+
+`check-hardcoded` reports Vue template text and static user-visible attributes:
+
+```txt
+i18n-smell-detector: hardcoded strings
+high=1 medium=1 low=0 ignored=4
+
+HIGH src/components/UserPanel.vue:12:15
+  value: "Profile settings"
+  reason: static template text
+
+MEDIUM src/components/SearchInput.vue:8:23
+  value: "Search"
+  reason: static placeholder attribute
+```
+
+JSON output includes source locations:
+
+```json
+{
+  "summary": {
+    "high": 1,
+    "medium": 1,
+    "low": 0,
+    "ignored": 4
+  },
+  "issues": [
+    {
+      "file": "src/components/UserPanel.vue",
+      "line": 12,
+      "column": 15,
+      "value": "Profile settings",
+      "severity": "high",
+      "reason": "static template text",
+      "kind": "vue-text"
+    }
+  ]
+}
+```
+
+## Running All Checks
+
+Use `check` to run every enabled check in one command:
+
+```bash
+npx i18n-smell-detector check --config i18n-smell.config.mjs
+```
+
+Disable checks during gradual rollout:
+
+```js
+export default {
+  checks: {
+    identical: true,
+    hardcoded: false
+  }
+};
+```
+
+Combined JSON output groups counts by check:
+
+```json
+{
+  "summary": {
+    "identical": {
+      "high": 2,
+      "medium": 1,
+      "low": 0,
+      "ignored": 16
+    },
+    "hardcoded": {
+      "high": 3,
+      "medium": 2,
+      "low": 0,
+      "ignored": 3
+    }
+  },
+  "issues": []
+}
+```
+
+## Writing Reports
+
+Use `--output` to write the full report to a file. The CLI prints a short summary to stdout after writing.
+
+```bash
+npx i18n-smell-detector check --format markdown --output reports/i18n-report.md
+npx i18n-smell-detector check --format json --output reports/i18n-report.json
+```
+
+Markdown output for `check` includes a summary table and one section per check, which makes it suitable for CI artifacts.
+
+## Gradual Adoption
+
+Use a baseline to ignore existing findings while still failing CI for new ones:
+
+```bash
+npx i18n-smell-detector check --baseline .i18n-smell-baseline.json --update-baseline
+npx i18n-smell-detector check --baseline .i18n-smell-baseline.json
+```
+
+The baseline stores stable issue identifiers. Updating it removes findings that no longer exist and records the current visible findings.
+
 ## Exit codes
 
 | Code | Meaning |
@@ -194,6 +398,8 @@ Ignored issues are omitted by default. Pass `--include-ignored` to include them
 | Single English word | medium |
 | English phrase | high |
 
+For `check-hardcoded`, sentence-like template text and static attributes are `high`, single words are `medium`, short common labels are `low`, and configured or non-user-facing values are `ignored`.
+
 ## False positive tuning
 
 Identical text is sometimes intentional. Start by running the detector in reporting mode, then allow known names, protocol terms, short labels, and other strings that should stay the same across languages.
@@ -236,6 +442,13 @@ Useful tuning patterns:
 - Set `ignoreSameLanguageFamily: false` if you want to check regional variants such as `en-GB`, `en-AU`, or `pt-BR`.
 - Set `failOn: 'none'` while tuning a new project, then raise it to `high` or `medium` once the allowlist is stable.
 - Pass `--include-ignored` when reviewing why a value was ignored.
+- Use `source` to choose Vue files for `check-hardcoded`.
+- Tune `hardcoded.vueAttributes` if your project uses additional static attributes for user-visible text.
+- Use `hardcoded.ignoreValues` and `hardcoded.ignorePatterns` for intentional literals such as `OK`, version labels, or product codes.
+
+## Limitations
+
+`check-hardcoded` currently scans Vue templates only. JavaScript, TypeScript, and JSX string detection are not included yet.
 
 ## Notes
 
@@ -249,6 +462,7 @@ Useful tuning patterns:
 npm install
 npm test
 npm run check
+npm run example:basic
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-smell-detector",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Find locale values copied from the base locale.",
   "type": "module",
   "bin": {
@@ -21,7 +21,10 @@
     "LICENSE"
   ],
   "scripts": {
-    "check": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
+    "check": "node ./bin/i18n-smell-detector.js check --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
+    "check:identical": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
+    "check:hardcoded": "node ./bin/i18n-smell-detector.js check-hardcoded --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
+    "example:basic": "node ./bin/i18n-smell-detector.js check --config ./examples/basic/i18n-smell.config.mjs --fail-on none",
     "test": "node --test"
   },
   "keywords": [
@@ -34,5 +37,10 @@
   "license": "MIT",
   "engines": {
     "node": ">=18.17"
+  },
+  "dependencies": {
+    "@vue/compiler-dom": "^3.5.39",
+    "@vue/compiler-sfc": "^3.5.39",
+    "fast-glob": "^3.3.3"
   }
 }

package/src/baseline.js

@@ -0,0 +1,75 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export function issueId(check, issue) {
+  if (check === 'identical') return `identical:${issue.targetLocale}:${issue.key}`;
+  return `hardcoded:${issue.file}:${issue.line}:${issue.column}:${issue.value}`;
+}
+
+export async function loadBaseline(filePath) {
+  if (!filePath) return new Set();
+
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(filePath, 'utf8'));
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') return new Set();
+    throw new Error(`Failed to read baseline file: ${filePath}\nReason: ${error.message}`);
+  }
+
+  if (!parsed || !Array.isArray(parsed.issues)) {
+    throw new Error(`Invalid baseline file: ${filePath}`);
+  }
+
+  return new Set(parsed.issues.map((issue) => issue.id).filter(Boolean));
+}
+
+export function applyBaseline(results, ids) {
+  if (!ids.size) return results;
+
+  return results.map((result) => ({
+    ...result,
+    issues: result.issues.map((issue) => {
+      const id = issueId(result.check, issue);
+      if (!ids.has(id)) return { ...issue, id };
+      return { ...issue, id, severity: 'ignored', reason: 'baseline' };
+    }),
+  }));
+}
+
+export async function writeBaseline(filePath, results) {
+  const issues = [];
+
+  for (const result of results) {
+    for (const issue of result.issues) {
+      if (issue.severity === 'ignored') continue;
+      issues.push(toBaselineIssue(result.check, issue));
+    }
+  }
+
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify({ version: 1, issues }, null, 2)}\n`);
+  return issues.length;
+}
+
+function toBaselineIssue(check, issue) {
+  const base = {
+    id: issueId(check, issue),
+    value: issue.value,
+  };
+
+  if (check === 'identical') {
+    return {
+      ...base,
+      key: issue.key,
+      targetLocale: issue.targetLocale,
+    };
+  }
+
+  return {
+    ...base,
+    file: issue.file,
+    line: issue.line,
+    column: issue.column,
+  };
+}

package/src/check-hardcoded.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import fg from 'fast-glob';
+import { scanVueSfc } from './source/scan-vue-sfc.js';
+
+function compareIssues(a, b) {
+  const rank = { high: 3, medium: 2, low: 1, ignored: 0 };
+  return rank[b.severity] - rank[a.severity]
+    || a.file.localeCompare(b.file)
+    || a.line - b.line
+    || a.column - b.column;
+}
+
+export async function checkHardcodedStrings(config, baseDir) {
+  const files = await fg(config.source, {
+    cwd: baseDir,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ['**/node_modules/**'],
+  });
+
+  if (files.length === 0) {
+    throw new Error(`No source files matched: ${config.source.join(', ')}`);
+  }
+
+  const issues = [];
+  for (const file of files) {
+    const fileIssues = await scanVueSfc(file, config);
+    for (const issue of fileIssues) {
+      issues.push({
+        ...issue,
+        file: path.relative(baseDir, issue.file),
+      });
+    }
+  }
+
+  return issues.sort(compareIssues);
+}

package/src/cli.js

@@ -1,32 +1,39 @@
+import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { checkIdenticalTranslations } from './check-identical.js';
+import { applyBaseline, loadBaseline, writeBaseline } from './baseline.js';
 import { loadConfig, resolveConfigPath } from './config.js';
-import { loadFlattenedLocales } from './locale/load-locales.js';
+import { flattenResults, renderCombinedReport, summarizeResults } from './reporters/combined.js';
 import { renderReport } from './reporters/index.js';
+import { enabledChecks, runChecks } from './run-checks.js';
 import { failRank, severityRank } from './severity.js';
 
 const HELP = `
-i18n-smell-detector v0.1.1
+i18n-smell-detector
 
 Usage:
   i18n-smell-detector check-identical [options]
+  i18n-smell-detector check-hardcoded [options]
   i18n-smell-detector check [options]
 
 Options:
   -c, --config <path>       Config file path
   --format <format>         console | json | markdown  (default: console)
   --fail-on <level>         high | medium | low | none (default: config.failOn or high)
+  --output <path>           Write the full report to a file
+  --baseline <path>         Read a baseline file
+  --update-baseline         Write the current issues to the baseline file
   --include-ignored         Print ignored matches as well
   -h, --help                Show help
 
 Example:
   i18n-smell-detector check-identical -c i18n-smell.config.mjs --format markdown
+  i18n-smell-detector check-hardcoded -c i18n-smell.config.mjs --format json
 `;
 
 function parseArgs(argv) {
   const args = argv.slice(2);
   const command = args[0] && !args[0].startsWith('-') ? args.shift() : 'check-identical';
-  const options = { command, format: 'console', includeIgnored: false, help: false };
+  const options = { command, includeIgnored: false, help: false, updateBaseline: false };
 
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
@@ -39,6 +46,12 @@ function parseArgs(argv) {
       options.format = readChoice(args[++index], ['console', 'json', 'markdown'], 'format');
     } else if (arg === '--fail-on') {
       options.failOn = readChoice(args[++index], ['none', 'low', 'medium', 'high'], 'fail-on level');
+    } else if (arg === '--output') {
+      options.output = args[++index];
+    } else if (arg === '--baseline') {
+      options.baseline = args[++index];
+    } else if (arg === '--update-baseline') {
+      options.updateBaseline = true;
     } else if (arg === '--include-ignored') {
       options.includeIgnored = true;
     } else {
@@ -64,7 +77,7 @@ export async function runCli(argv) {
     return;
   }
 
-  if (!['check-identical', 'check'].includes(options.command)) {
+  if (!['check-identical', 'check-hardcoded', 'check'].includes(options.command)) {
     throw new Error(`Unknown command: ${options.command}\n${HELP}`);
   }
 
@@ -73,18 +86,88 @@ export async function runCli(argv) {
   const effectiveConfig = {
     ...config,
     failOn: options.failOn || config.failOn || 'high',
+    format: options.format || config.format || 'console',
+    output: options.output || config.output,
+    baseline: options.baseline || config.baseline,
     includeIgnored: options.includeIgnored || config.includeIgnored || false,
   };
 
-  const locales = await loadFlattenedLocales(effectiveConfig, path.dirname(configPath));
-  const issues = checkIdenticalTranslations(locales, effectiveConfig);
+  const configDir = path.dirname(configPath);
+  const checks = commandChecks(options.command, effectiveConfig);
+  const rawResults = await runChecks(effectiveConfig, configDir, checks);
 
-  console.log(renderReport(issues, {
-    format: options.format,
+  if (options.updateBaseline) {
+    if (!effectiveConfig.baseline) throw new Error('Baseline path is required for --update-baseline');
+    const baselinePath = resolveFromConfigDir(effectiveConfig.baseline, configDir);
+    const count = await writeBaseline(baselinePath, rawResults);
+    console.log(`Baseline updated: ${effectiveConfig.baseline} (${count} issues)`);
+    return;
+  }
+
+  const baselineIds = await loadBaseline(resolveOptional(effectiveConfig.baseline, configDir));
+  const results = applyBaseline(rawResults, baselineIds);
+  const reportOptions = {
+    format: effectiveConfig.format,
     includeIgnored: effectiveConfig.includeIgnored || false,
-  }));
+  };
+  const report = options.command === 'check'
+    ? renderCombinedReport(results, reportOptions)
+    : renderSingleReport(results[0], reportOptions);
+
+  if (effectiveConfig.output) {
+    await writeOutput(resolveFromConfigDir(effectiveConfig.output, configDir), report);
+    console.log(renderWriteSummary(results, effectiveConfig.output));
+  } else {
+    console.log(report);
+  }
 
-  const visible = effectiveConfig.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
+  const visible = options.command === 'check'
+    ? flattenResults(results, { includeIgnored: effectiveConfig.includeIgnored || false })
+    : visibleIssues(results[0].issues, effectiveConfig.includeIgnored || false);
   const shouldFail = visible.some((issue) => severityRank[issue.severity] >= failRank(effectiveConfig.failOn || 'high'));
   if (shouldFail) process.exit(1);
 }
+
+function commandChecks(command, config) {
+  if (command === 'check-identical') return ['identical'];
+  if (command === 'check-hardcoded') return ['hardcoded'];
+  return enabledChecks(config);
+}
+
+function renderSingleReport(result, options) {
+  return renderReport(result.issues, {
+    ...options,
+    title: result.title,
+    heading: result.heading,
+    emptyMessage: result.emptyMessage,
+  });
+}
+
+function visibleIssues(issues, includeIgnored) {
+  return includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
+}
+
+function resolveFromConfigDir(filePath, configDir) {
+  return path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath);
+}
+
+function resolveOptional(filePath, configDir) {
+  return filePath ? resolveFromConfigDir(filePath, configDir) : undefined;
+}
+
+async function writeOutput(filePath, report) {
+  try {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, report);
+  } catch (error) {
+    throw new Error(`Failed to write report file: ${filePath}\nReason: ${error.message}`);
+  }
+}
+
+function renderWriteSummary(results, output) {
+  const summary = summarizeResults(results);
+  const counts = Object.entries(summary)
+    .map(([check, item]) => `${check}: high=${item.high} medium=${item.medium} low=${item.low} ignored=${item.ignored}`)
+    .join('; ');
+  return `Report written to ${output}\n${counts}`;
+}

package/src/config.js

@@ -17,6 +17,14 @@ const DEFAULT_PLACEHOLDER_PATTERNS = [
   String.raw`\{[^}]+\}`,
 ];
 
+const DEFAULT_HARDCODED_ATTRIBUTES = [
+  'placeholder',
+  'title',
+  'alt',
+  'aria-label',
+  'aria-description',
+];
+
 async function exists(filePath) {
   try {
     await access(filePath);
@@ -81,6 +89,37 @@ function validateConfig(config) {
   if ('placeholderPatterns' in candidate && !Array.isArray(candidate.placeholderPatterns)) {
     throw new Error('Config placeholderPatterns must be an array of strings or RegExp objects');
   }
+
+  if ('source' in candidate && !isStringArray(candidate.source)) {
+    throw new Error('Config source must be an array of glob strings');
+  }
+
+  if ('hardcoded' in candidate && (!candidate.hardcoded || typeof candidate.hardcoded !== 'object' || Array.isArray(candidate.hardcoded))) {
+    throw new Error('Config hardcoded must be an object');
+  }
+
+  if ('checks' in candidate && (!candidate.checks || typeof candidate.checks !== 'object' || Array.isArray(candidate.checks))) {
+    throw new Error('Config checks must be an object');
+  }
+
+  if ('format' in candidate && !['console', 'json', 'markdown'].includes(candidate.format)) {
+    throw new Error('Config format must be console, json, or markdown');
+  }
+
+  if ('output' in candidate && typeof candidate.output !== 'string') {
+    throw new Error('Config output must be a file path string');
+  }
+
+  if ('baseline' in candidate && typeof candidate.baseline !== 'string') {
+    throw new Error('Config baseline must be a file path string');
+  }
+
+  const hardcoded = /** @type {Record<string, unknown>} */ (candidate.hardcoded || {});
+  if ('vueAttributes' in hardcoded && !isStringArray(hardcoded.vueAttributes)) {
+    throw new Error('Config hardcoded.vueAttributes must be an array of strings');
+  }
+  validateRuleList(hardcoded.ignoreValues, 'hardcoded.ignoreValues');
+  validateRuleList(hardcoded.ignorePatterns, 'hardcoded.ignorePatterns');
 }
 
 /** @param {import('./types.js').DetectorConfig} config */
@@ -95,12 +134,28 @@ function withDefaults(config) {
     ignoreCase: false,
     includeIgnored: false,
     failOn: 'high',
+    checks: {
+      identical: true,
+      hardcoded: true,
+      ...(config.checks || {}),
+    },
     ...config,
+    checks: {
+      identical: true,
+      hardcoded: true,
+      ...(config.checks || {}),
+    },
+    source: config.source || ['src/**/*.vue'],
+    hardcoded: normalizeHardcodedConfig(config.hardcoded || {}),
     placeholderPatterns: normalizePlaceholderPatterns(config.placeholderPatterns || DEFAULT_PLACEHOLDER_PATTERNS),
     ignoreCodeLike: config.ignoreCodeLike ?? true,
   };
 }
 
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string' && item.length > 0);
+}
+
 function validateRuleList(rules, name) {
   if (rules === undefined) return;
   if (!Array.isArray(rules)) throw new Error(`Config ${name} must be an array`);
@@ -128,6 +183,29 @@ function normalizePlaceholderPatterns(patterns) {
   });
 }
 
+function normalizeHardcodedConfig(config) {
+  return {
+    vueAttributes: config.vueAttributes || DEFAULT_HARDCODED_ATTRIBUTES,
+    ignoreValues: config.ignoreValues || [],
+    ignorePatterns: normalizeRegexRules(config.ignorePatterns || [], 'hardcoded.ignorePatterns'),
+  };
+}
+
+function normalizeRegexRules(rules, name) {
+  return rules.map((rule) => {
+    if (rule instanceof RegExp) return rule;
+    if (typeof rule !== 'string') {
+      throw new Error(`Config ${name} entries must be strings or RegExp objects`);
+    }
+
+    try {
+      return new RegExp(rule);
+    } catch (error) {
+      throw new Error(`Invalid ${name} pattern "${rule}": ${error.message}`);
+    }
+  });
+}
+
 function withGlobalFlag(pattern) {
   const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
   return new RegExp(pattern.source, flags);

package/src/reporters/combined.js

@@ -0,0 +1,66 @@
+import { renderConsoleReport } from './console.js';
+import { renderMarkdownReport } from './markdown.js';
+import { summarizeIssues } from './summary.js';
+
+export function renderCombinedReport(results, options) {
+  if (options.format === 'json') return renderCombinedJson(results, options);
+  if (options.format === 'markdown') return renderCombinedMarkdown(results, options);
+  return renderCombinedConsole(results, options);
+}
+
+export function flattenResults(results, options) {
+  return results.flatMap((result) => {
+    const issues = options.includeIgnored ? result.issues : result.issues.filter((issue) => issue.severity !== 'ignored');
+    return issues.map((issue) => ({ check: result.check, ...issue }));
+  });
+}
+
+export function summarizeResults(results) {
+  return Object.fromEntries(results.map((result) => [result.check, summarizeIssues(result.issues)]));
+}
+
+function renderCombinedJson(results, options) {
+  return `${JSON.stringify({
+    summary: summarizeResults(results),
+    issues: flattenResults(results, options),
+  }, null, 2)}\n`;
+}
+
+function renderCombinedConsole(results, options) {
+  return results.map((result) => renderConsoleReport(result.issues, {
+    ...options,
+    title: result.title,
+    emptyMessage: result.emptyMessage,
+  })).join('\n\n');
+}
+
+function renderCombinedMarkdown(results, options) {
+  const lines = [
+    '# i18n-smell-detector report',
+    '',
+    '## Summary',
+    '',
+    '| Check | High | Medium | Low | Ignored |',
+    '|---|---:|---:|---:|---:|',
+  ];
+
+  for (const result of results) {
+    const summary = summarizeIssues(result.issues);
+    lines.push(`| ${result.check} | ${summary.high} | ${summary.medium} | ${summary.low} | ${summary.ignored} |`);
+  }
+
+  for (const result of results) {
+    lines.push('');
+    lines.push(asSection(renderMarkdownReport(result.issues, {
+      ...options,
+      heading: result.heading,
+      emptyMessage: result.emptyMessage,
+    }).trim()));
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function asSection(markdown) {
+  return markdown.replace(/^# /, '## ');
+}

package/src/reporters/console.js

@@ -21,21 +21,26 @@ export function renderConsoleReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
   const counts = summarizeIssues(issues);
   const lines = [
-    color('1', 'i18n-smell-detector: identical translations'),
+    color('1', `i18n-smell-detector: ${options.title || 'identical translations'}`),
     `high=${counts.high} medium=${counts.medium} low=${counts.low} ignored=${counts.ignored}`,
   ];
 
   if (visible.length === 0) {
-    lines.push(color('32', 'No copied base-locale values found.'));
+    lines.push(color('32', options.emptyMessage || 'No copied base-locale values found.'));
     return lines.join('\n');
   }
 
   lines.push('');
   for (const issue of visible) {
-    lines.push(`${label(issue.severity)} ${issue.targetLocale}.${issue.key}`);
+    lines.push(`${label(issue.severity)} ${formatLocation(issue)}`);
     lines.push(`  value: "${preview(issue.value)}"`);
     lines.push(`  reason: ${issue.reason}`);
   }
 
   return lines.join('\n');
 }
+
+function formatLocation(issue) {
+  if (issue.file) return `${issue.file}:${issue.line}:${issue.column}`;
+  return `${issue.targetLocale}.${issue.key}`;
+}

package/src/reporters/markdown.js

@@ -8,24 +8,41 @@ export function renderMarkdownReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
   const summary = summarizeIssues(issues);
   const lines = [
-    '# Identical translations',
+    `# ${options.heading || 'Identical translations'}`,
     '',
     `high=${summary.high} medium=${summary.medium} low=${summary.low} ignored=${summary.ignored}`,
     '',
   ];
 
   if (visible.length === 0) {
-    lines.push('No copied base-locale values found.');
+    lines.push(options.emptyMessage || 'No copied base-locale values found.');
     return `${lines.join('\n')}\n`;
   }
 
-  lines.push('| Level | Locale | Key | Value | Reason |');
-  lines.push('|---|---|---|---|---|');
+  if (visible.some((issue) => issue.file)) {
+    lines.push('| Level | Location | Value | Reason |');
+    lines.push('|---|---|---|---|');
+  } else {
+    lines.push('| Level | Locale | Key | Value | Reason |');
+    lines.push('|---|---|---|---|---|');
+  }
+
   for (const issue of visible) {
-    lines.push(
-      `| ${escapeCell(issue.severity)} | ${escapeCell(issue.targetLocale)} | ${escapeCell(issue.key)} | ${escapeCell(issue.value)} | ${escapeCell(issue.reason)} |`
-    );
+    if (issue.file) {
+      lines.push(
+        `| ${escapeCell(issue.severity)} | ${escapeCell(formatLocation(issue))} | ${escapeCell(issue.value)} | ${escapeCell(issue.reason)} |`
+      );
+    } else {
+      lines.push(
+        `| ${escapeCell(issue.severity)} | ${escapeCell(issue.targetLocale)} | ${escapeCell(issue.key)} | ${escapeCell(issue.value)} | ${escapeCell(issue.reason)} |`
+      );
+    }
   }
 
   return `${lines.join('\n')}\n`;
 }
+
+function formatLocation(issue) {
+  if (issue.file) return `${issue.file}:${issue.line}:${issue.column}`;
+  return `${issue.targetLocale}.${issue.key}`;
+}

package/src/rules/classify-hardcoded.js

@@ -0,0 +1,54 @@
+import { matchesAnyRule } from './match-rule.js';
+
+function isBlank(value) {
+  return value.trim().length === 0;
+}
+
+function isMustacheOnly(value) {
+  return /^\{\{[\s\S]*\}\}$/.test(value.trim());
+}
+
+function isNonUserFacing(value) {
+  const text = value.trim();
+  return /^[0-9.,:;+\-*/%()\s]+$/.test(text)
+    || /^[\p{P}\p{S}]+$/u.test(text)
+    || /^#[0-9a-f]{3,8}$/i.test(text)
+    || /^(https?:\/\/|mailto:|tel:)/i.test(text)
+    || /^\/[a-z0-9_./:-]*$/i.test(text)
+    || /^[a-z0-9_.-]+\.(css|js|png|jpe?g|gif|svg|webp|json)$/i.test(text)
+    || /^[A-Z]{2,6}$/.test(text);
+}
+
+function latinWords(value) {
+  return value.match(/[A-Za-z][A-Za-z']*/g) || [];
+}
+
+function isShortCommonLabel(value) {
+  const text = value.trim();
+  return text.length <= 3 || /^(ok|id|no|yes|on|off)$/i.test(text);
+}
+
+export function classifyHardcoded(value, config = {}) {
+  const hardcoded = config.hardcoded || {};
+
+  if (matchesAnyRule(value, hardcoded.ignoreValues || [])) {
+    return { severity: 'ignored', reason: 'ignored value' };
+  }
+
+  if (matchesAnyRule(value, hardcoded.ignorePatterns || [])) {
+    return { severity: 'ignored', reason: 'ignored pattern' };
+  }
+
+  if (isBlank(value)) return { severity: 'ignored', reason: 'blank value' };
+  if (isMustacheOnly(value)) return { severity: 'ignored', reason: 'mustache expression' };
+  if (isNonUserFacing(value)) return { severity: 'ignored', reason: 'non-user-facing value' };
+  if (isShortCommonLabel(value)) return { severity: 'low', reason: 'short common label' };
+
+  const words = latinWords(value);
+  if (words.length >= 2 || /[.!?。！？]/.test(value)) {
+    return { severity: 'high', reason: 'sentence-like content' };
+  }
+
+  if (words.length === 1) return { severity: 'medium', reason: 'single word' };
+  return { severity: 'low', reason: 'possible user-facing text' };
+}

package/src/run-checks.js

@@ -0,0 +1,35 @@
+import { checkHardcodedStrings } from './check-hardcoded.js';
+import { checkIdenticalTranslations } from './check-identical.js';
+import { loadFlattenedLocales } from './locale/load-locales.js';
+
+const CHECK_META = {
+  identical: {
+    title: 'identical translations',
+    heading: 'Identical translations',
+    emptyMessage: 'No copied base-locale values found.',
+  },
+  hardcoded: {
+    title: 'hardcoded strings',
+    heading: 'Hardcoded strings',
+    emptyMessage: 'No hardcoded strings found.',
+  },
+};
+
+export async function runChecks(config, configDir, names) {
+  const results = [];
+
+  for (const check of names) {
+    if (check === 'identical') {
+      const locales = await loadFlattenedLocales(config, configDir);
+      results.push({ check, ...CHECK_META[check], issues: checkIdenticalTranslations(locales, config) });
+    } else if (check === 'hardcoded') {
+      results.push({ check, ...CHECK_META[check], issues: await checkHardcodedStrings(config, configDir) });
+    }
+  }
+
+  return results;
+}
+
+export function enabledChecks(config) {
+  return ['identical', 'hardcoded'].filter((check) => config.checks[check]);
+}

package/src/source/scan-vue-sfc.js

@@ -0,0 +1,26 @@
+import { readFile } from 'node:fs/promises';
+import { parse } from '@vue/compiler-sfc';
+import { scanVueTemplate } from './scan-vue-template.js';
+
+function lineOffsetBefore(source, offset) {
+  return source.slice(0, offset).split(/\r?\n/).length - 1;
+}
+
+export async function scanVueSfc(file, config) {
+  const source = await readFile(file, 'utf8');
+  const result = parse(source, { filename: file });
+
+  if (result.errors.length > 0) {
+    const [error] = result.errors;
+    throw new Error(`Malformed Vue file ${file}: ${error.message || String(error)}`);
+  }
+
+  const template = result.descriptor.template;
+  if (!template) return [];
+
+  return scanVueTemplate(template.content, {
+    file,
+    lineOffset: lineOffsetBefore(source, template.loc.start.offset),
+    config,
+  });
+}

package/src/source/scan-vue-template.js

@@ -0,0 +1,105 @@
+import { NodeTypes, parse } from '@vue/compiler-dom';
+import { classifyHardcoded } from '../rules/classify-hardcoded.js';
+
+function offsetToLocation(source, offset) {
+  const before = source.slice(0, offset);
+  const lines = before.split(/\r?\n/);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1,
+  };
+}
+
+function normalizeText(value) {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function isI18nExpression(value) {
+  return /\b(?:t|te|\$t|i18n\.t)\s*\(/.test(value);
+}
+
+function makeIssue({ file, lineOffset, template, loc, value, kind, reason, severity }) {
+  const start = offsetToLocation(template, loc.start.offset);
+  return {
+    file,
+    line: lineOffset + start.line,
+    column: start.column,
+    value,
+    severity,
+    reason,
+    kind,
+  };
+}
+
+function scanValue({ file, lineOffset, template, loc, value, kind, baseReason, config }) {
+  const text = normalizeText(value);
+  if (!text) return null;
+
+  const classification = classifyHardcoded(text, config);
+  return makeIssue({
+    file,
+    lineOffset,
+    template,
+    loc,
+    value: text,
+    severity: classification.severity,
+    reason: classification.severity === 'ignored' ? classification.reason : baseReason,
+    kind,
+  });
+}
+
+function walk(node, visitor) {
+  visitor(node);
+  for (const child of node.children || []) walk(child, visitor);
+}
+
+export function scanVueTemplate(template, { file, lineOffset = 0, config }) {
+  let ast;
+  try {
+    ast = parse(template, { comments: false });
+  } catch (error) {
+    throw new Error(`Malformed Vue template in ${file}: ${error.message}`);
+  }
+
+  const attributes = new Set(config.hardcoded.vueAttributes);
+  const issues = [];
+
+  walk(ast, (node) => {
+    if (node.type === NodeTypes.TEXT) {
+      const issue = scanValue({
+        file,
+        lineOffset,
+        template,
+        loc: node.loc,
+        value: node.content,
+        kind: 'vue-text',
+        baseReason: 'static template text',
+        config,
+      });
+      if (issue) issues.push(issue);
+      return;
+    }
+
+    if (node.type !== NodeTypes.ELEMENT) return;
+
+    for (const prop of node.props || []) {
+      if (prop.type !== NodeTypes.ATTRIBUTE) continue;
+      if (!attributes.has(prop.name) || !prop.value) continue;
+      if (isI18nExpression(prop.value.content)) continue;
+
+      const issue = scanValue({
+        file,
+        lineOffset,
+        template,
+        loc: prop.value.loc,
+        value: prop.value.content,
+        kind: `vue-attribute:${prop.name}`,
+        baseReason: `static ${prop.name} attribute`,
+        config,
+      });
+      if (issue) issues.push(issue);
+    }
+  });
+
+  return issues;
+}

package/src/types.js

@@ -8,6 +8,12 @@
  * @property {(string | RegExp)[]=} allowIdenticalKeys
  * @property {(string | RegExp)[]=} allowIdenticalValues
  * @property {(string | RegExp)[]=} placeholderPatterns
+ * @property {string[]=} source
+ * @property {{vueAttributes: string[], ignoreValues: (string | RegExp)[], ignorePatterns: RegExp[]}=} hardcoded
+ * @property {{identical: boolean, hardcoded: boolean}=} checks
+ * @property {ReportFormat=} format
+ * @property {string=} output
+ * @property {string=} baseline
  * @property {boolean=} ignoreCodeLike
  * @property {boolean=} ignoreSameLanguageFamily
  * @property {boolean=} trimWhitespace
@@ -22,6 +28,15 @@
  * @property {string} value
  * @property {Severity} severity
  * @property {string} reason
+ *
+ * @typedef {Object} HardcodedIssue
+ * @property {string} file
+ * @property {number} line
+ * @property {number} column
+ * @property {string} value
+ * @property {Severity} severity
+ * @property {string} reason
+ * @property {string} kind
  */
 
 export {};