@jaimevalasek/aioson 1.3.0

package/src/context.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {
+  CONTEXT_REQUIRED_FIELDS,
+  CONTEXT_ALLOWED_CLASSIFICATIONS,
+  CONTEXT_ALLOWED_PROJECT_TYPES,
+  CONTEXT_ALLOWED_PROFILES
+} = require('./constants');
+const { exists } = require('./utils');
+
+function stripOuterQuotes(value) {
+  const text = String(value || '').trim();
+  if (
+    (text.startsWith('"') && text.endsWith('"')) ||
+    (text.startsWith("'") && text.endsWith("'"))
+  ) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function parseScalar(value) {
+  const text = stripOuterQuotes(value);
+  if (text === 'true') return true;
+  if (text === 'false') return false;
+  return text;
+}
+
+function parseYamlFrontmatter(markdown) {
+  const text = String(markdown || '');
+  if (!text.startsWith('---\n') && !text.startsWith('---\r\n')) {
+    return {
+      ok: false,
+      data: null,
+      reason: 'missing_frontmatter'
+    };
+  }
+
+  const lines = text.split(/\r?\n/);
+  let closingIndex = -1;
+  for (let i = 1; i < lines.length; i += 1) {
+    if (lines[i].trim() === '---') {
+      closingIndex = i;
+      break;
+    }
+  }
+
+  if (closingIndex === -1) {
+    return {
+      ok: false,
+      data: null,
+      reason: 'unclosed_frontmatter'
+    };
+  }
+
+  const data = {};
+  for (let i = 1; i < closingIndex; i += 1) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith('#')) continue;
+
+    const match = line.match(/^([a-zA-Z0-9_]+)\s*:\s*(.*)$/);
+    if (!match) {
+      return {
+        ok: false,
+        data: null,
+        reason: 'invalid_frontmatter_line',
+        line
+      };
+    }
+
+    const key = match[1];
+    const rawValue = match[2];
+    data[key] = parseScalar(rawValue);
+  }
+
+  return {
+    ok: true,
+    data
+  };
+}
+
+function isValidLanguageTag(value) {
+  const tag = String(value || '').trim();
+  return /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/.test(tag);
+}
+
+function validateContextData(data) {
+  const issues = [];
+
+  for (const key of CONTEXT_REQUIRED_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      issues.push({
+        id: `context:missing:${key}`,
+        key: 'doctor.context_required_field',
+        params: { field: key },
+        hintKey: 'doctor.context_required_field_hint'
+      });
+    }
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(data, 'framework_installed') &&
+    typeof data.framework_installed !== 'boolean'
+  ) {
+    issues.push({
+      id: 'context:framework_installed:type',
+      key: 'doctor.context_framework_installed_type',
+      params: {},
+      hintKey: 'doctor.context_framework_installed_type_hint'
+    });
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(data, 'classification') &&
+    !CONTEXT_ALLOWED_CLASSIFICATIONS.includes(String(data.classification))
+  ) {
+    issues.push({
+      id: 'context:classification:value',
+      key: 'doctor.context_classification_value',
+      params: { expected: CONTEXT_ALLOWED_CLASSIFICATIONS.join('|') },
+      hintKey: 'doctor.context_classification_value_hint'
+    });
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(data, 'project_type') &&
+    !CONTEXT_ALLOWED_PROJECT_TYPES.includes(String(data.project_type))
+  ) {
+    issues.push({
+      id: 'context:project_type:value',
+      key: 'doctor.context_project_type_value',
+      params: { expected: CONTEXT_ALLOWED_PROJECT_TYPES.join('|') },
+      hintKey: 'doctor.context_project_type_value_hint'
+    });
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(data, 'profile') &&
+    !CONTEXT_ALLOWED_PROFILES.includes(String(data.profile))
+  ) {
+    issues.push({
+      id: 'context:profile:value',
+      key: 'doctor.context_profile_value',
+      params: { expected: CONTEXT_ALLOWED_PROFILES.join('|') },
+      hintKey: 'doctor.context_profile_value_hint'
+    });
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(data, 'conversation_language') &&
+    !isValidLanguageTag(data.conversation_language)
+  ) {
+    issues.push({
+      id: 'context:conversation_language:format',
+      key: 'doctor.context_conversation_language_format',
+      params: {},
+      hintKey: 'doctor.context_conversation_language_format_hint'
+    });
+  }
+
+  return issues;
+}
+
+async function validateProjectContextFile(targetDir) {
+  const filePath = path.join(targetDir, '.aioson/context/project.context.md');
+  if (!(await exists(filePath))) {
+    return {
+      exists: false,
+      parsed: false,
+      valid: false,
+      filePath,
+      data: null,
+      issues: []
+    };
+  }
+
+  const content = await fs.readFile(filePath, 'utf8');
+  const parsed = parseYamlFrontmatter(content);
+  if (!parsed.ok) {
+    return {
+      exists: true,
+      parsed: false,
+      valid: false,
+      filePath,
+      data: null,
+      parseError: parsed.reason,
+      issues: [
+        {
+          id: 'context:frontmatter:invalid',
+          key: 'doctor.context_frontmatter_invalid',
+          params: { reason: parsed.reason },
+          hintKey: 'doctor.context_frontmatter_invalid_hint'
+        }
+      ]
+    };
+  }
+
+  const issues = validateContextData(parsed.data);
+  return {
+    exists: true,
+    parsed: true,
+    valid: issues.length === 0,
+    filePath,
+    data: parsed.data,
+    issues
+  };
+}
+
+module.exports = {
+  parseYamlFrontmatter,
+  validateContextData,
+  validateProjectContextFile,
+  isValidLanguageTag
+};
+

package/src/detector.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const path = require('node:path');
+const { exists, readTextIfExists } = require('./utils');
+
+function safeJsonParse(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+function dependencyExists(pkg, names) {
+  if (!pkg) return false;
+  const sections = [
+    pkg.require || {},
+    pkg['require-dev'] || {},
+    pkg.dependencies || {},
+    pkg.devDependencies || {},
+    pkg.peerDependencies || {},
+    pkg.optionalDependencies || {}
+  ];
+
+  return sections.some((section) => names.some((name) => Object.prototype.hasOwnProperty.call(section, name)));
+}
+
+function includesToken(text, token) {
+  if (!text) return false;
+  return text.toLowerCase().includes(token.toLowerCase());
+}
+
+async function detectFramework(projectDir) {
+  const checks = [];
+
+  const packageJsonPath = path.join(projectDir, 'package.json');
+  const composerJsonPath = path.join(projectDir, 'composer.json');
+  const gemfilePath = path.join(projectDir, 'Gemfile');
+  const requirementsPath = path.join(projectDir, 'requirements.txt');
+  const pyprojectPath = path.join(projectDir, 'pyproject.toml');
+  const cargoTomlPath = path.join(projectDir, 'Cargo.toml');
+
+  const [packageText, composerText, gemfileText, requirementsText, pyprojectText, cargoTomlText] = await Promise.all([
+    readTextIfExists(packageJsonPath),
+    readTextIfExists(composerJsonPath),
+    readTextIfExists(gemfilePath),
+    readTextIfExists(requirementsPath),
+    readTextIfExists(pyprojectPath),
+    readTextIfExists(cargoTomlPath)
+  ]);
+
+  const packageJson = safeJsonParse(packageText || '');
+  const composerJson = safeJsonParse(composerText || '');
+
+  const hasArtisan = await exists(path.join(projectDir, 'artisan'));
+  const hasLaravelComposer = dependencyExists(composerJson, ['laravel/framework']);
+  if (hasArtisan || hasLaravelComposer) {
+    checks.push({ framework: 'Laravel', installed: true, evidence: hasArtisan ? 'artisan' : 'composer.json:laravel/framework', confidence: 'high' });
+  }
+
+  const hasCodeIgniter4Spark = await exists(path.join(projectDir, 'spark'));
+  const hasCodeIgniter4AppConfig = await exists(path.join(projectDir, 'app/Config/App.php'));
+  const hasCodeIgniter4Composer = dependencyExists(composerJson, ['codeigniter4/framework']);
+  if (hasCodeIgniter4Spark || hasCodeIgniter4AppConfig || hasCodeIgniter4Composer) {
+    checks.push({
+      framework: 'CodeIgniter 4',
+      installed: true,
+      evidence: hasCodeIgniter4Spark
+        ? 'spark'
+        : hasCodeIgniter4AppConfig
+          ? 'app/Config/App.php'
+          : 'composer.json:codeigniter4/framework',
+      confidence: hasCodeIgniter4Spark || hasCodeIgniter4AppConfig ? 'high' : 'medium'
+    });
+  }
+
+  const hasCodeIgniter3Core = await exists(path.join(projectDir, 'system/core/CodeIgniter.php'));
+  const hasCodeIgniter3Config = await exists(path.join(projectDir, 'application/config/config.php'));
+  if (hasCodeIgniter3Core || hasCodeIgniter3Config) {
+    checks.push({
+      framework: 'CodeIgniter 3',
+      installed: true,
+      evidence: hasCodeIgniter3Core ? 'system/core/CodeIgniter.php' : 'application/config/config.php',
+      confidence: 'high'
+    });
+  }
+
+  const hasSymfonyConsole = await exists(path.join(projectDir, 'bin/console'));
+  const hasSymfonyComposer = dependencyExists(composerJson, ['symfony/framework-bundle']);
+  if (hasSymfonyConsole || hasSymfonyComposer) {
+    checks.push({ framework: 'Symfony', installed: true, evidence: hasSymfonyConsole ? 'bin/console' : 'composer.json:symfony/framework-bundle', confidence: 'high' });
+  }
+
+  const hasRailsApp = await exists(path.join(projectDir, 'config/application.rb'));
+  const hasRailsGem = includesToken(gemfileText, 'gem "rails"') || includesToken(gemfileText, "gem 'rails'");
+  if (hasRailsApp || hasRailsGem) {
+    checks.push({ framework: 'Rails', installed: true, evidence: hasRailsApp ? 'config/application.rb' : 'Gemfile:rails', confidence: hasRailsApp ? 'high' : 'medium' });
+  }
+
+  const hasManagePy = await exists(path.join(projectDir, 'manage.py'));
+  const hasDjangoReq = includesToken(requirementsText, 'django');
+  const hasDjangoPyproject = includesToken(pyprojectText, 'django');
+  if (hasManagePy || hasDjangoReq || hasDjangoPyproject) {
+    checks.push({ framework: 'Django', installed: true, evidence: hasManagePy ? 'manage.py' : hasDjangoReq ? 'requirements.txt:django' : 'pyproject.toml:django', confidence: hasManagePy ? 'high' : 'medium' });
+  }
+
+  const hasHardhatConfig =
+    (await exists(path.join(projectDir, 'hardhat.config.js'))) ||
+    (await exists(path.join(projectDir, 'hardhat.config.ts')));
+  const hasHardhatDep = dependencyExists(packageJson, ['hardhat']);
+  if (hasHardhatConfig || hasHardhatDep) {
+    checks.push({
+      framework: 'Hardhat',
+      installed: true,
+      evidence: hasHardhatConfig ? 'hardhat.config.*' : 'package.json:hardhat',
+      confidence: hasHardhatConfig ? 'high' : 'medium'
+    });
+  }
+
+  const hasFoundryToml = await exists(path.join(projectDir, 'foundry.toml'));
+  if (hasFoundryToml) {
+    checks.push({
+      framework: 'Foundry',
+      installed: true,
+      evidence: 'foundry.toml',
+      confidence: 'high'
+    });
+  }
+
+  const hasTruffleConfig =
+    (await exists(path.join(projectDir, 'truffle-config.js'))) ||
+    (await exists(path.join(projectDir, 'truffle-config.ts')));
+  const hasTruffleDep = dependencyExists(packageJson, ['truffle']);
+  if (hasTruffleConfig || hasTruffleDep) {
+    checks.push({
+      framework: 'Truffle',
+      installed: true,
+      evidence: hasTruffleConfig ? 'truffle-config.*' : 'package.json:truffle',
+      confidence: hasTruffleConfig ? 'high' : 'medium'
+    });
+  }
+
+  const hasAnchorToml = await exists(path.join(projectDir, 'Anchor.toml'));
+  const hasAnchorDep = dependencyExists(packageJson, ['@coral-xyz/anchor']);
+  const hasAnchorCargo = includesToken(cargoTomlText, 'anchor-lang');
+  if (hasAnchorToml || hasAnchorDep || hasAnchorCargo) {
+    checks.push({
+      framework: 'Anchor',
+      installed: true,
+      evidence: hasAnchorToml
+        ? 'Anchor.toml'
+        : hasAnchorDep
+          ? 'package.json:@coral-xyz/anchor'
+          : 'Cargo.toml:anchor-lang',
+      confidence: hasAnchorToml ? 'high' : 'medium'
+    });
+  }
+
+  const hasSolanaWeb3Dep = dependencyExists(packageJson, ['@solana/web3.js']);
+  if (hasSolanaWeb3Dep && !checks.some((check) => check.framework === 'Anchor')) {
+    checks.push({
+      framework: 'Solana Web3',
+      installed: true,
+      evidence: 'package.json:@solana/web3.js',
+      confidence: 'medium'
+    });
+  }
+
+  const hasAikenToml = await exists(path.join(projectDir, 'aiken.toml'));
+  const hasCardanoDep = dependencyExists(packageJson, [
+    'lucid-cardano',
+    '@meshsdk/core',
+    '@cardano-ogmios/client'
+  ]);
+  if (hasAikenToml || hasCardanoDep) {
+    checks.push({
+      framework: 'Cardano',
+      installed: true,
+      evidence: hasAikenToml ? 'aiken.toml' : 'package.json:cardano dependencies',
+      confidence: hasAikenToml ? 'high' : 'medium'
+    });
+  }
+
+  const hasNextConfig = (await exists(path.join(projectDir, 'next.config.js'))) || (await exists(path.join(projectDir, 'next.config.ts')));
+  const hasNextDep = dependencyExists(packageJson, ['next']);
+  if (hasNextConfig || hasNextDep) {
+    checks.push({ framework: 'Next.js', installed: true, evidence: hasNextConfig ? 'next.config.*' : 'package.json:next', confidence: hasNextConfig ? 'high' : 'medium' });
+  }
+
+  const hasNuxtConfig = (await exists(path.join(projectDir, 'nuxt.config.js'))) || (await exists(path.join(projectDir, 'nuxt.config.ts')));
+  const hasNuxtDep = dependencyExists(packageJson, ['nuxt']);
+  if (hasNuxtConfig || hasNuxtDep) {
+    checks.push({ framework: 'Nuxt', installed: true, evidence: hasNuxtConfig ? 'nuxt.config.*' : 'package.json:nuxt', confidence: hasNuxtConfig ? 'high' : 'medium' });
+  }
+
+  const hasSvelteConfig = await exists(path.join(projectDir, 'svelte.config.js'));
+  const hasSvelteKitDep = dependencyExists(packageJson, ['@sveltejs/kit']);
+  if (hasSvelteConfig || hasSvelteKitDep) {
+    checks.push({ framework: 'SvelteKit', installed: true, evidence: hasSvelteConfig ? 'svelte.config.js' : 'package.json:@sveltejs/kit', confidence: hasSvelteConfig ? 'high' : 'medium' });
+  }
+
+  const hasRemixConfig = (await exists(path.join(projectDir, 'remix.config.js'))) || (await exists(path.join(projectDir, 'remix.config.ts')));
+  const hasRemixDep = dependencyExists(packageJson, ['@remix-run/react', '@remix-run/node']);
+  if (hasRemixConfig || hasRemixDep) {
+    checks.push({ framework: 'Remix', installed: true, evidence: hasRemixConfig ? 'remix.config.*' : 'package.json:@remix-run/*', confidence: hasRemixConfig ? 'high' : 'medium' });
+  }
+
+  const hasAdonisAce = await exists(path.join(projectDir, 'ace'));
+  const hasAdonisDep = dependencyExists(packageJson, ['@adonisjs/core']);
+  if (hasAdonisAce || hasAdonisDep) {
+    checks.push({ framework: 'AdonisJS', installed: true, evidence: hasAdonisAce ? 'ace' : 'package.json:@adonisjs/core', confidence: hasAdonisAce ? 'high' : 'medium' });
+  }
+
+  const hasNodePackage = await exists(packageJsonPath);
+  if (checks.length === 0 && hasNodePackage) {
+    checks.push({ framework: 'Node', installed: true, evidence: 'package.json', confidence: 'low' });
+  }
+
+  if (checks.length === 0) {
+    return {
+      framework: null,
+      installed: false,
+      evidence: null,
+      confidence: 'none',
+      matches: []
+    };
+  }
+
+  return {
+    framework: checks[0].framework,
+    installed: true,
+    evidence: checks[0].evidence,
+    confidence: checks[0].confidence,
+    matches: checks
+  };
+}
+
+const WEB3_FRAMEWORKS = new Set(['Hardhat', 'Foundry', 'Truffle', 'Anchor', 'Solana Web3', 'Cardano']);
+const BACKEND_FRAMEWORKS = new Set(['Laravel', 'Rails', 'Django', 'Symfony', 'AdonisJS', 'CodeIgniter 4', 'CodeIgniter 3']);
+const FRONTEND_FRAMEWORKS = new Set(['Next.js', 'Nuxt', 'SvelteKit', 'Remix']);
+
+/**
+ * Returns true when detection found both a Web3 framework and a backend or
+ * frontend framework in the same directory — typical of monorepos that bundle
+ * smart contracts alongside a web application.
+ */
+function isMonorepoDetection(detection) {
+  if (!detection || !Array.isArray(detection.matches) || detection.matches.length < 2) return false;
+  const names = detection.matches.map((m) => m.framework);
+  const hasWeb3 = names.some((n) => WEB3_FRAMEWORKS.has(n));
+  const hasBackend = names.some((n) => BACKEND_FRAMEWORKS.has(n));
+  const hasFrontend = names.some((n) => FRONTEND_FRAMEWORKS.has(n));
+  return hasWeb3 && (hasBackend || hasFrontend);
+}
+
+module.exports = {
+  detectFramework,
+  isMonorepoDetection,
+  safeJsonParse,
+  dependencyExists
+};