tadforce 0.0.0-stage → 0.2.0

package/src/facts/extractors/ui.js

@@ -0,0 +1,120 @@
+import path from 'node:path';
+import { bundles, files, baseName, readXml, arr, bool, str, byName, safeRead } from '../xml.js';
+
+const camel = (kebab) => kebab.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+
+export function extractUi(roots) {
+  const lwc = bundles(roots, 'lwc').filter((b) => !b.name.startsWith('__')).map((b) => {
+    const meta = readXml(path.join(b.dir, `${b.name}.js-meta.xml`));
+    const js = files([b.dir], '.', '.js').map(safeRead).join('\n');
+    const html = files([b.dir], '.', '.html').map(safeRead).join('\n');
+    const targets = arr(meta.targets && meta.targets.target).map(String).sort();
+    return {
+      name: b.name,
+      label: str(meta.masterLabel),
+      exposed: bool(meta.isExposed),
+      targets,
+      apex: [...new Set([...js.matchAll(/@salesforce\/apex\/([A-Za-z0-9_]+)\.[A-Za-z0-9_]+/g)].map((m) => m[1]))].sort(),
+      children: [...new Set([...html.matchAll(/<c-([a-z0-9-]+)/g)].map((m) => camel(m[1])).concat([...js.matchAll(/from\s+['"]c\/([A-Za-z0-9_]+)['"]/g)].map((m) => m[1])))].sort(),
+      usesMessageChannel: /lightning\/messageService/.test(js),
+      usesNavigation: /lightning\/navigation/.test(js),
+      usesWire: /@wire\s*\(/.test(js),
+      service: !html.trim(),
+    };
+  });
+
+  const aura = bundles(roots, 'aura').map((b) => {
+    const markup = files([b.dir], '.', '').filter((f) => /\.(cmp|app|evt|intf|design)$/.test(f)).map(safeRead).join('\n');
+    return {
+      name: b.name,
+      type: files([b.dir], '.', '.app').length ? 'application' : files([b.dir], '.', '.evt').length ? 'event' : 'component',
+      controller: (/controller\s*=\s*"([A-Za-z0-9_.]+)"/i.exec(markup) || [])[1] || null,
+      children: [...new Set([...markup.matchAll(/<c:([A-Za-z0-9_]+)/g)].map((m) => m[1]))].sort(),
+    };
+  });
+
+  const vfPages = files(roots, 'pages', '.page').map((f) => {
+    const src = safeRead(f);
+    const tag = (/<apex:page[^>]*>/i.exec(src) || [''])[0];
+    return {
+      name: baseName(f, '.page'),
+      controller: (/\bcontroller\s*=\s*"([^"]+)"/i.exec(tag) || [])[1] || null,
+      extensions: ((/\bextensions\s*=\s*"([^"]+)"/i.exec(tag) || [])[1] || '').split(',').map((s) => s.trim()).filter(Boolean),
+    };
+  }).sort(byName);
+
+  const flexipages = files(roots, 'flexipages', '.flexipage-meta.xml').map((f) => {
+    const raw = safeRead(f);
+    const x = readXml(f);
+    const comps = [...raw.matchAll(/<componentName>([^<]+)<\/componentName>/g)].map((m) => m[1].trim());
+    return {
+      name: baseName(f, '.flexipage-meta.xml'),
+      label: str(x.masterLabel),
+      type: str(x.type),
+      object: str(x.sobjectType),
+      template: str(x.template && x.template.name),
+      customComponents: [...new Set(comps.filter((c) => !c.includes(':')))].sort(),
+      standardComponents: comps.filter((c) => c.includes(':')).length,
+    };
+  }).sort(byName);
+
+  const apps = files(roots, 'applications', '.app-meta.xml').map((f) => {
+    const x = readXml(f);
+    return {
+      name: baseName(f, '.app-meta.xml'),
+      label: str(x.label),
+      navType: str(x.navType),
+      uiType: str(x.uiType),
+      formFactors: arr(x.formFactors).map(String).sort(),
+      tabs: arr(x.tabs).map(String),
+      utilityBar: str(x.utilityBar),
+      console: str(x.navType) === 'Console',
+    };
+  }).sort(byName);
+
+  const tabs = files(roots, 'tabs', '.tab-meta.xml').map((f) => {
+    const x = readXml(f);
+    const kind = x.customObject ? 'object' : x.lwcComponent ? 'lwc' : x.flexiPage ? 'page' : x.url ? 'web' : x.page ? 'visualforce' : x.auraComponent ? 'aura' : 'other';
+    return { name: baseName(f, '.tab-meta.xml'), kind, lwc: str(x.lwcComponent), aura: str(x.auraComponent), flexiPage: str(x.flexiPage), label: str(x.label) };
+  }).sort(byName);
+
+  const quickActions = files(roots, 'quickActions', '.quickAction-meta.xml').map((f) => {
+    const x = readXml(f);
+    return { name: baseName(f, '.quickAction-meta.xml'), type: str(x.type), lwc: str(x.lightningWebComponent), aura: str(x.lightningComponent), flow: str(x.flowDefinition), object: str(x.targetObject) };
+  }).sort(byName);
+
+  const messageChannels = files(roots, 'messageChannels', '.messageChannel-meta.xml').map((f) => baseName(f, '.messageChannel-meta.xml')).sort();
+  return { lwc, aura, vfPages, flexipages, apps, tabs, quickActions, messageChannels, vfComponents: files(roots, 'components', '.component').length };
+}
+
+/**
+ * Where is each LWC / Aura component used? Scans pages, apps, tabs, actions, flows,
+ * OmniStudio and Experience bundles. Result: { name: [{ kind, name }] }.
+ */
+export function placements(roots, ui) {
+  const used = {};
+  const add = (comp, kind, name) => { if (!comp) return; (used[comp] ||= []).push({ kind, name }); };
+  for (const p of ui.flexipages) for (const c of p.customComponents) add(c, 'flexipage', p.name);
+  for (const l of ui.lwc) for (const c of l.children) add(c, 'lwc', l.name);
+  for (const a of ui.aura) for (const c of a.children) add(c, 'aura', a.name);
+  for (const tb of ui.tabs) { add(tb.lwc, 'tab', tb.name); add(tb.aura, 'tab', tb.name); }
+  for (const q of ui.quickActions) { add(q.lwc, 'quickAction', q.name); add(q.aura, 'quickAction', q.name); }
+  const scan = (folder, kind, re) => {
+    for (const f of files(roots, folder, '', { recursive: true })) {
+      const raw = safeRead(f);
+      for (const m of raw.matchAll(re)) add(m[1], kind, path.basename(f).split('.')[0]);
+    }
+  };
+  scan('flows', 'flow', /<extensionName>c:([A-Za-z0-9_]+)<\/extensionName>/g);
+  const omniRe = /lwcName(?:&quot;|")\s*:\s*(?:&quot;|")([A-Za-z0-9_]+)/g;
+  scan('omniScripts', 'omniScript', omniRe);
+  scan('omniUiCard', 'flexCard', omniRe);
+  scan('experiences', 'experience', /"c:([A-Za-z0-9_]+)"/g);
+  scan('digitalExperiences', 'experience', /"c:([A-Za-z0-9_]+)"/g);
+  for (const k of Object.keys(used)) {
+    const seen = new Set();
+    used[k] = used[k].filter((u) => { const key = u.kind + ':' + u.name; if (seen.has(key)) return false; seen.add(key); return true; })
+      .sort((a, b) => (a.kind + a.name).localeCompare(b.kind + b.name));
+  }
+  return used;
+}

package/src/facts/fingerprints.js

@@ -0,0 +1,32 @@
+// Content fingerprints of the metadata, one per file: what `tadforce update` compares between two versions.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { walk, toPosix } from '../util/fsx.js';
+
+/** Metadata folder → facts.json area it feeds. */
+export const AREAS = {
+  classes: 'apex', triggers: 'apex',
+  objects: 'data', customMetadata: 'data.cmdtTypes', globalValueSets: 'data',
+  flows: 'automation.flows', workflows: 'automation',
+  omniScripts: 'automation.omnistudio', omniIntegrationProcedures: 'automation.omnistudio', omniDataTransforms: 'automation.omnistudio', omniUiCard: 'automation.omnistudio',
+  lwc: 'ui', aura: 'ui', pages: 'ui', components: 'ui', flexipages: 'ui', applications: 'ui', tabs: 'ui', quickActions: 'ui', messageChannels: 'ui', experiences: 'ui', digitalExperiences: 'ui', callCenters: 'integration',
+  permissionsets: 'security', permissionsetgroups: 'security', profiles: 'security', roles: 'security', queues: 'security', groups: 'security', sharingRules: 'security', customPermissions: 'security',
+  namedCredentials: 'integration', externalCredentials: 'integration', remoteSiteSettings: 'integration', connectedApps: 'integration', authproviders: 'integration', cspTrustedSites: 'integration', corsWhitelistOrigins: 'integration', externalServiceRegistrations: 'integration',
+  reports: 'misc', dashboards: 'misc', reportTypes: 'misc', staticresources: 'misc', labels: 'misc', email: 'misc',
+  genAiPlugins: 'modules', genAiFunctions: 'modules', genAiPromptTemplates: 'modules', bots: 'modules',
+};
+
+/** One hash per metadata file, keyed by its path from the type folder (classes/Foo.cls). */
+export function fingerprints(dirs) {
+  const out = {};
+  for (const dir of dirs) {
+    for (const f of walk(dir)) {
+      const parts = toPosix(path.relative(dir, f)).split('/');
+      const i = parts.findIndex((p) => AREAS[p]);
+      if (i < 0) continue;
+      out[parts.slice(i).join('/')] = crypto.createHash('sha1').update(fs.readFileSync(f)).digest('hex').slice(0, 16);
+    }
+  }
+  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
+}

package/src/facts/heuristics/exclusions.js

@@ -0,0 +1,143 @@
+// Exclusions are decided by humans (knowledge/exclusions.yml). Heuristics only propose candidates.
+
+/** Every component collection of facts.json, addressable by a short type name. */
+export const COLLECTIONS = [
+  ['apex', (f) => f.apex.classes],
+  ['trigger', (f) => f.apex.triggers],
+  ['lwc', (f) => f.ui.lwc],
+  ['aura', (f) => f.ui.aura],
+  ['vfPage', (f) => f.ui.vfPages],
+  ['flexipage', (f) => f.ui.flexipages],
+  ['app', (f) => f.ui.apps],
+  ['tab', (f) => f.ui.tabs],
+  ['quickAction', (f) => f.ui.quickActions],
+  ['flow', (f) => f.automation.flows],
+  ['omniScript', (f) => f.automation.omnistudio.omniScripts],
+  ['integrationProcedure', (f) => f.automation.omnistudio.integrationProcedures],
+  ['dataMapper', (f) => f.automation.omnistudio.dataMappers],
+  ['flexCard', (f) => f.automation.omnistudio.flexCards],
+  ['object', (f) => f.data.objects],
+  ['cmdt', (f) => f.data.cmdtTypes, 'type'],
+  ['profile', (f) => f.security.profiles],
+  ['permissionSet', (f) => f.security.permissionSets],
+  ['permissionSetGroup', (f) => f.security.permissionSetGroups],
+  ['role', (f) => f.security.roles],
+  ['queue', (f) => f.security.queues],
+  ['namedCredential', (f) => f.integration.namedCredentials],
+  ['externalCredential', (f) => f.integration.externalCredentials],
+  ['remoteSite', (f) => f.integration.remoteSites],
+  ['connectedApp', (f) => f.integration.connectedApps],
+  ['authProvider', (f) => f.integration.authProviders],
+  ['report', (f) => f.misc.reports.names, null],
+  ['dashboard', (f) => f.misc.dashboards.names, null],
+  ['emailTemplate', (f) => f.misc.emailTemplates, null],
+  ['staticResource', (f) => f.misc.staticResources, null],
+];
+
+const keyOf = (item, field) => (field === null ? item : item[field || 'name']);
+
+function matcher(pattern) {
+  const re = new RegExp('^' + String(pattern).replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$', 'i');
+  return (s) => re.test(String(s));
+}
+
+/** Remove excluded components from facts (in place). Returns the list of applied exclusions. */
+export function applyExclusions(facts, knowledge = {}) {
+  const rules = [...(knowledge.exclude || [])];
+  for (const feat of knowledge.features || []) {
+    for (const c of feat.components || []) rules.push({ name: typeof c === 'string' ? c : c.name, type: c.type, reason: `${feat.name}${feat.note ? ' — ' + feat.note : ''}`, feature: feat.name });
+  }
+  const applied = [];
+  for (const rule of rules) {
+    if (!rule || !rule.name) continue;
+    const match = matcher(rule.name);
+    for (const [type, get, field] of COLLECTIONS) {
+      if (rule.type && rule.type !== 'any' && rule.type !== type) continue;
+      const list = get(facts);
+      if (!Array.isArray(list)) continue;
+      for (let i = list.length - 1; i >= 0; i--) {
+        const k = keyOf(list[i], field);
+        if (match(k)) {
+          applied.push({ type, name: k, reason: rule.reason || null, feature: rule.feature || null });
+          list.splice(i, 1);
+        }
+      }
+    }
+  }
+  return applied.sort((a, b) => (a.type + a.name).localeCompare(b.type + b.name));
+}
+
+// Org-wide components (profiles, roles, queues, report folders…) are shared by every project: never scoped out.
+const SCOPED_TYPES = new Set(['apex', 'trigger', 'lwc', 'aura', 'vfPage', 'flexipage', 'app', 'tab', 'quickAction', 'flow', 'omniScript', 'integrationProcedure', 'dataMapper', 'flexCard', 'object', 'cmdt', 'permissionSet', 'permissionSetGroup', 'namedCredential', 'externalCredential', 'remoteSite', 'connectedApp', 'authProvider', 'staticResource']);
+
+/**
+ * Keep only the part of the org a project owns (tadforce.config.json › scope.include, name patterns with `*`).
+ * Standard objects stay: a project extends them, it does not own them. Returns the components set aside.
+ */
+export function applyScope(facts, scope = {}) {
+  const include = (scope.include || []).filter(Boolean).map(matcher);
+  if (!include.length) return [];
+  const out = [];
+  for (const [type, get, field] of COLLECTIONS) {
+    if (!SCOPED_TYPES.has(type)) continue;
+    const list = get(facts);
+    if (!Array.isArray(list)) continue;
+    for (let i = list.length - 1; i >= 0; i--) {
+      const k = keyOf(list[i], field);
+      if (type === 'object' && !String(k).includes('__')) continue;
+      if (type === 'apex' && list[i].test && include.some((m) => m(String(k).replace(/_?Tests?$/i, '')))) continue;
+      if (!include.some((m) => m(k))) { out.push({ type, name: k }); list.splice(i, 1); }
+    }
+  }
+  return out.sort((a, b) => (a.type + a.name).localeCompare(b.type + b.name));
+}
+
+const SUSPICIOUS = new Set(['test', 'tests', 'poc', 'demo', 'demos', 'sample', 'samples', 'dryrun', 'repro', 'tmp', 'temp', 'old', 'deprecated', 'obsolete', 'backup', 'bkp', 'copy', 'draft', 'example', 'examples', 'playground', 'todelete', 'unused', 'legacy', 'dummy', 'fake', 'mock']);
+
+export function nameWords(name) {
+  return String(name)
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .split(/[^A-Za-z]+/)
+    .map((w) => w.toLowerCase())
+    .filter(Boolean);
+}
+
+/**
+ * Propose exclusion candidates (never applied automatically): suspicious names, components
+ * placed nowhere, inactive automation, Apex referenced only by tests.
+ */
+export function exclusionCandidates(facts, refs) {
+  const out = [];
+  const add = (type, name, reason) => out.push({ type, name, reason });
+  for (const [type, get, field] of COLLECTIONS) {
+    const list = get(facts) || [];
+    for (const item of list) {
+      const name = keyOf(item, field);
+      if (type === 'apex' && item.test) continue;
+      const bad = nameWords(name).filter((w) => SUSPICIOUS.has(w));
+      if (bad.length) add(type, name, `name suggests ${bad.join('/')}`);
+    }
+  }
+  for (const l of facts.ui.lwc) if (!refs.placements[l.name]) add('lwc', l.name, 'not placed on any page, app, tab, action, flow or OmniStudio component in the snapshot');
+  for (const a of facts.ui.aura) if (a.type === 'component' && !refs.placements[a.name]) add('aura', a.name, 'not referenced by any page, app, tab, action or component in the snapshot');
+  for (const fl of facts.automation.flows) if (!fl.active) add('flow', fl.name, `flow status is ${fl.status}`);
+  for (const k of ['omniScripts', 'integrationProcedures', 'dataMappers', 'flexCards']) {
+    for (const o of facts.automation.omnistudio[k]) if (!o.active) add(k.replace(/s$/, ''), o.name, 'inactive version');
+  }
+  const ENTRY = new Set(['rest', 'soap', 'schedulable', 'invocable', 'registrationHandler', 'emailHandler', 'global']);
+  for (const c of facts.apex.classes) {
+    if (c.test || c.kinds.some((k) => ENTRY.has(k))) continue;
+    if (!refs.apexReferenced.has(c.name)) add('apex', c.name, refs.apexReferencedByTests.has(c.name) ? 'referenced only by test classes' : 'not referenced by any other component in the snapshot');
+  }
+  for (const p of facts.ui.flexipages) {
+    if (!refs.flexipageAssigned.has(p.name)) add('flexipage', p.name, 'not assigned to any app, object override or tab in the snapshot');
+  }
+  // merge duplicates (one entry per component, reasons joined)
+  const merged = {};
+  for (const c of out) {
+    const k = c.type + ':' + c.name;
+    if (merged[k]) { if (!merged[k].reasons.includes(c.reason)) merged[k].reasons.push(c.reason); } else merged[k] = { type: c.type, name: c.name, reasons: [c.reason] };
+  }
+  return Object.values(merged).sort((a, b) => (a.type + a.name).localeCompare(b.type + b.name));
+}

package/src/facts/heuristics/modules.js

@@ -0,0 +1,85 @@
+// Which Salesforce products this org uses, from evidence in the metadata only.
+// Each detected cloud maps to a reference in skills/tadforce/references/modules/ and to
+// conditional sections of the skeletons (<!-- tad:if modules.<flag> -->).
+
+const has = (set, ...names) => names.some((n) => set.has(n));
+
+/**
+ * Evidence rules. `objects`: standard objects whose presence in the snapshot (with custom fields,
+ * record types or page usage) signals the product; `ns`: managed package namespaces; `test`: other signals.
+ */
+const CLOUDS = [
+  { id: 'salesCloud', name: 'Sales Cloud', ref: 'sales-cloud', objects: ['Opportunity', 'Lead', 'Quote', 'Forecasting', 'Territory2', 'OpportunityLineItem', 'ActionCadence'], test: (f) => f.misc.folders.territory2Models > 0 || f.misc.folders.forecastingTypes > 0 },
+  { id: 'serviceCloud', name: 'Service Cloud', ref: 'service-cloud', objects: ['Case', 'Entitlement', 'ServiceContract', 'MessagingSession', 'LiveChatTranscript', 'VoiceCall', 'CaseMilestone'], test: (f) => f.misc.signals.entitlementProcesses > 0 || f.misc.signals.serviceChannels > 0 || f.data.objects.some((o) => o.name.endsWith('__kav')) },
+  { id: 'fieldService', name: 'Field Service', ref: 'field-service', ns: ['FSL'], objects: ['WorkOrder', 'ServiceAppointment', 'ServiceTerritory', 'ServiceResource', 'WorkOrderLineItem', 'MaintenancePlan'] },
+  { id: 'experienceCloud', name: 'Experience Cloud', ref: 'experience-cloud', test: (f) => f.misc.signals.networks + f.misc.signals.experiences + f.misc.signals.sites > 0 },
+  { id: 'marketingCloud', name: 'Marketing Cloud Connect', ref: 'marketing', ns: ['et4ae5'] },
+  { id: 'accountEngagement', name: 'Marketing Cloud Account Engagement', ref: 'marketing', ns: ['pi'] },
+  { id: 'commerce', name: 'Commerce Cloud (B2B / D2C)', ref: 'commerce', objects: ['WebStore', 'WebCart', 'ProductCatalog', 'BuyerGroup', 'BuyerAccount', 'CommerceEntitlementPolicy'] },
+  { id: 'orderManagement', name: 'Order Management', ref: 'commerce', objects: ['OrderSummary', 'FulfillmentOrder', 'OrderDeliveryGroupSummary', 'ReturnOrder'] },
+  { id: 'cpq', name: 'Salesforce CPQ', ref: 'revenue-cpq', ns: ['SBQQ'] },
+  { id: 'billing', name: 'Salesforce Billing', ref: 'revenue-cpq', ns: ['blng'] },
+  { id: 'revenueCloud', name: 'Revenue Cloud', ref: 'revenue-cpq', objects: ['ProductSellingModel', 'ProductSellingModelOption', 'BillingSchedule', 'Invoice', 'ProductClassification'] },
+  { id: 'financialServices', name: 'Financial Services Cloud', ref: 'industries', ns: ['FinServ'], objects: ['FinancialAccount', 'FinancialAccountRole', 'FinancialGoal', 'PartyProfile', 'ResidentialLoanApplication'] },
+  { id: 'insurance', name: 'Insurance (Financial Services Cloud)', ref: 'industries', ns: ['vlocity_ins'], objects: ['InsurancePolicy', 'InsurancePolicyCoverage', 'Claim', 'Producer', 'InsurancePolicyParticipant'] },
+  { id: 'healthCloud', name: 'Health Cloud', ref: 'industries', ns: ['HealthCloudGA'], objects: ['CarePlan', 'CareProgram', 'ClinicalEncounter', 'HealthcareProvider', 'PatientMedicalProcedure'] },
+  { id: 'lifeSciences', name: 'Life Sciences Cloud', ref: 'industries', objects: ['LifeSciMarketableProduct', 'ProviderVisit', 'ClinicalStudy'] },
+  { id: 'manufacturing', name: 'Manufacturing Cloud', ref: 'industries', objects: ['SalesAgreement', 'AccountForecast', 'SalesAgreementProduct', 'WarrantyTerm'] },
+  { id: 'automotive', name: 'Automotive Cloud', ref: 'industries', objects: ['Vehicle', 'VehicleDefinition', 'DriverQualification'] },
+  { id: 'consumerGoods', name: 'Consumer Goods Cloud', ref: 'industries', ns: ['cgcloud'], objects: ['RetailStore', 'Visit', 'RetailVisitKpi', 'InStoreLocation'] },
+  { id: 'communications', name: 'Communications / Media / Energy & Utilities Cloud', ref: 'industries', ns: ['vlocity_cmt'], objects: ['ServicePoint', 'BillingAccount'] },
+  { id: 'publicSector', name: 'Public Sector Solutions', ref: 'industries', ns: ['vlocity_ps'], objects: ['IndividualApplication', 'BusinessLicense', 'RegulatoryCode', 'PublicComplaint', 'BenefitAssignment'] },
+  { id: 'education', name: 'Education Cloud', ref: 'industries', ns: ['hed'], objects: ['LearnerProfile', 'AcademicTermEnrollment', 'LearningProgram', 'ProgramEnrollment'] },
+  { id: 'nonprofit', name: 'Nonprofit (Nonprofit Cloud / NPSP)', ref: 'industries', ns: ['npsp', 'npe01', 'npo02', 'npe03', 'npe4', 'npe5'], objects: ['GiftTransaction', 'GiftCommitment', 'Program', 'ProgramEnrollment'] },
+  { id: 'loyalty', name: 'Loyalty Management', ref: 'industries', objects: ['LoyaltyProgram', 'LoyaltyProgramMember', 'LoyaltyLedger', 'TransactionJournal'] },
+  { id: 'netZero', name: 'Net Zero Cloud', ref: 'industries', objects: ['StnryAssetCrbnFtprnt', 'VehicleAssetCrbnFtprnt', 'Scope3CrbnFtprnt'] },
+  { id: 'omnistudio', name: 'OmniStudio', ref: 'omnistudio', ns: ['omnistudio', 'vlocity_cmt', 'vlocity_ins', 'vlocity_ps'], test: (f) => Object.values(f.automation.omnistudio).some((l) => l.length > 0) },
+  { id: 'dataCloud', name: 'Data Cloud', ref: 'data-cloud', test: (f) => f.misc.signals.dataStreams > 0 || f.data.objects.some((o) => /__(dlm|dll)$/.test(o.name)) || (f.misc.folders.dataStreamDefinitions || 0) + (f.misc.folders.dataSourceObjects || 0) > 0 },
+  { id: 'agentforce', name: 'Agentforce / Einstein', ref: 'agentforce-ai', test: (f) => f.misc.signals.bots + f.misc.signals.genAi > 0 || (f.misc.folders.genAiPromptTemplates || 0) + (f.misc.folders.mlPredictionDefinitions || 0) > 0 },
+  { id: 'crmAnalytics', name: 'CRM Analytics', ref: 'analytics', ns: ['wave'], test: (f) => ['wave', 'waveDashboards', 'waveDataflows', 'waveRecipes', 'waveApplications', 'waveDatasets'].some((k) => f.misc.folders[k] > 0) },
+  { id: 'shield', name: 'Shield (encryption, event monitoring, audit)', ref: 'security-shield', test: (f) => ['transactionSecurityPolicies', 'eventSubscriptions'].some((k) => f.misc.folders[k] > 0) || f.misc.settings.some((s) => /PlatformEncryption|EventSettings|FieldHistoryRetention/.test(s)) },
+  { id: 'slack', name: 'Slack integration', ref: 'integration-platforms', ns: ['slackv2', 'slack'], test: (f) => (f.misc.folders.slackApps || 0) > 0 },
+  { id: 'events', name: 'Platform Events / Change Data Capture', ref: 'platform-events', test: (f) => f.data.objects.some((o) => o.kind === 'platformEvent') || f.data.cdc.length > 0 },
+];
+
+/** Standard objects count as evidence when the org customised or uses them. */
+function usedStandard(f) {
+  const used = new Set();
+  for (const o of f.data.objects) if (o.kind === 'standard' && (o.customFields > 0 || o.recordTypes.length || o.validationRules.length)) used.add(o.name);
+  for (const p of f.ui.flexipages) if (p.object) used.add(p.object);
+  for (const t of f.apex.triggers) if (t.object) used.add(t.object);
+  for (const fl of f.automation.flows) if (fl.object) used.add(fl.object);
+  for (const q of f.security.queues) q.objects.forEach((x) => used.add(x));
+  return used;
+}
+
+export function detectModules(f) {
+  const ns = new Set(f.namespaces.map((n) => n.namespace));
+  const std = usedStandard(f);
+  const clouds = [];
+  const flags = {};
+  for (const c of CLOUDS) {
+    const evidence = [];
+    for (const n of c.ns || []) if (ns.has(n)) evidence.push(`namespace ${n}`);
+    for (const o of c.objects || []) if (std.has(o) || f.data.objects.some((x) => x.name === o && x.kind === 'standard' && x.customFields > 0)) evidence.push(`object ${o}`);
+    if (c.test && c.test(f)) evidence.push('metadata');
+    const on = evidence.length > 0;
+    flags[c.id] = on;
+    if (on) clouds.push({ id: c.id, name: c.name, reference: c.ref, evidence: [...new Set(evidence)].slice(0, 6) });
+  }
+  const industryIds = ['financialServices', 'insurance', 'healthCloud', 'lifeSciences', 'manufacturing', 'automotive', 'consumerGoods', 'communications', 'publicSector', 'education', 'nonprofit', 'loyalty', 'netZero'];
+  const products = [...new Set([...clouds.map((c) => c.name), ...f.namespaces.filter((n) => n.product).map((n) => n.product)])].sort();
+  return {
+    ...flags,
+    industryCloud: clouds.filter((c) => industryIds.includes(c.id)).map((c) => c.name),
+    omniChannel: f.misc.signals.serviceChannels + f.misc.signals.routingConfigs > 0,
+    cti: f.integration.callCenters.length > 0,
+    visualforce: f.ui.vfPages.length > 0,
+    aura: f.ui.aura.length > 0,
+    legacyAutomation: f.automation.rules.workflowRules + f.automation.rules.processBuilders > 0,
+    mobile: f.ui.apps.some((a) => a.formFactors.includes('Small')),
+    clouds,
+    references: [...new Set(clouds.map((c) => c.reference))].sort(),
+    products,
+  };
+}

package/src/facts/heuristics/naming.js

@@ -0,0 +1,31 @@
+// Observed naming conventions: most frequent prefixes and suffixes per component family.
+const SUFFIXES = ['TriggerHandler', 'Handler', 'Controller', 'Service', 'Selector', 'Domain', 'Batch', 'Queueable', 'Scheduler', 'Schedulable', 'Helper', 'Utils', 'Util', 'Manager', 'Engine', 'Factory', 'Wrapper', 'DTO', 'Mock', 'Test', 'Exception', 'Callout', 'Client', 'Resource', 'Api'];
+
+function top(map, n = 6, min = 2) {
+  return Object.entries(map).filter(([, c]) => c >= min).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, n).map(([value, count]) => ({ value, count }));
+}
+
+function prefixOf(name) {
+  const m = /^([A-Za-z]+\d*_)/.exec(name) || /^([a-z]+\d+)/.exec(name) || /^([A-Z]{2,5})(?=[A-Z][a-z])/.exec(name);
+  return m ? m[1] : null;
+}
+
+function prefixes(names) {
+  const counts = {};
+  for (const n of names) { const p = prefixOf(n); if (p) counts[p] = (counts[p] || 0) + 1; }
+  return top(counts);
+}
+
+export function detectNaming(f) {
+  const classes = f.apex.classes.map((c) => c.name);
+  const suffixCounts = {};
+  for (const n of classes) { const s = SUFFIXES.find((x) => n.endsWith(x)); if (s) suffixCounts[s] = (suffixCounts[s] || 0) + 1; }
+  return {
+    apex: { prefixes: prefixes(classes), suffixes: top(suffixCounts, 10, 1) },
+    triggers: { prefixes: prefixes(f.apex.triggers.map((t) => t.name)) },
+    lwc: { prefixes: prefixes(f.ui.lwc.map((l) => l.name)) },
+    flows: { prefixes: prefixes(f.automation.flows.map((x) => x.name)) },
+    objects: { prefixes: prefixes(f.data.objects.filter((o) => o.kind === 'custom' && !o.namespace).map((o) => o.name)) },
+    permissionSets: { prefixes: prefixes(f.security.permissionSets.map((p) => p.name)) },
+  };
+}

package/src/facts/heuristics/signals.js

@@ -0,0 +1,76 @@
+// Review signals for the Improvement Axes document. A signal is a measurable observation,
+// not a verdict: the architect confirms, qualifies and prioritises it.
+
+const list = (items, n = 12) => items.slice(0, n);
+
+export function computeSignals(f, org = null, codeAnalyzer = null) {
+  const s = [];
+  const add = (id, pillar, priority, value, evidence = [], extra = {}) => { if (value) s.push({ id, pillar, priority, value, evidence: list(evidence), total: evidence.length, ...extra }); };
+  const app = f.apex.classes.filter((c) => !c.test);
+  const tests = f.apex.classes.filter((c) => c.test);
+
+  const versions = [...app, ...f.apex.triggers, ...f.automation.flows].map((x) => parseFloat(x.apiVersion)).filter((v) => !Number.isNaN(v));
+  const maxApi = versions.length ? Math.max(...versions) : null;
+  if (maxApi) {
+    const old = [...app, ...f.apex.triggers].filter((x) => parseFloat(x.apiVersion) <= maxApi - 15);
+    add('api-version-old', 'adaptable', 'p3', old.length, old.map((x) => `${x.name} (${x.apiVersion})`), { threshold: `≤ ${(maxApi - 15).toFixed(1)}` });
+  }
+  const without = app.filter((c) => c.sharing === 'without');
+  add('without-sharing', 'trusted', 'p2', without.length, without.map((c) => c.name));
+  const none = app.filter((c) => c.sharing === 'none' && !c.kinds.includes('interface') && !c.kinds.includes('enum'));
+  add('no-sharing-keyword', 'trusted', 'p3', none.length, none.map((c) => c.name));
+  const ids = app.filter((c) => c.hardcodedIds > 0);
+  add('hardcoded-ids', 'adaptable', 'p2', ids.length, ids.map((c) => c.name));
+  const loops = app.filter((c) => c.soqlInLoops > 0);
+  add('soql-dml-in-loops', 'easy', 'p2', loops.length, loops.map((c) => `${c.name} (${c.soqlInLoops})`));
+  const big = app.filter((c) => c.lines > 1000);
+  add('large-classes', 'adaptable', 'p3', big.length, big.map((c) => `${c.name} (${c.lines} lines)`));
+
+  const perObject = {};
+  for (const t of f.apex.triggers) (perObject[t.object] ||= []).push(t.name);
+  const multi = Object.entries(perObject).filter(([, v]) => v.length > 1);
+  add('multiple-triggers-per-object', 'adaptable', 'p2', multi.length, multi.map(([o, v]) => `${o}: ${v.join(', ')}`));
+  const fat = f.apex.triggers.filter((t) => t.lines > 30);
+  add('logic-in-triggers', 'adaptable', 'p3', fat.length, fat.map((t) => `${t.name} (${t.lines} lines)`));
+
+  if (app.length) {
+    const ratio = tests.length / app.length;
+    if (ratio < 0.5) add('low-test-ratio', 'trusted', 'p2', `${tests.length}/${app.length}`, [], { ratio: Math.round(ratio * 100) / 100 });
+  }
+  if (org && typeof org.coverage === 'number') {
+    if (org.coverage < 75) add('org-coverage', 'trusted', 'p1', `${org.coverage}%`);
+    else if (org.coverage < 85) add('org-coverage', 'trusted', 'p3', `${org.coverage}%`);
+  }
+
+  add('aura-residual', 'adaptable', 'p3', f.ui.aura.length, f.ui.aura.map((a) => a.name));
+  add('visualforce-residual', 'adaptable', 'p3', f.ui.vfPages.length, f.ui.vfPages.map((p) => p.name));
+  add('workflow-rules', 'adaptable', 'p2', f.automation.rules.workflowRules);
+  add('process-builders', 'adaptable', 'p2', f.automation.rules.processBuilders, f.automation.flows.filter((x) => x.processType === 'Workflow').map((x) => x.name));
+  const inactive = f.automation.flows.filter((x) => !x.active);
+  add('inactive-flows', 'easy', 'p3', inactive.length, inactive.map((x) => `${x.name} (${x.status})`));
+  const flowsPerObject = {};
+  for (const fl of f.automation.flows.filter((x) => x.active && x.object && /Record/.test(x.triggerType || ''))) (flowsPerObject[fl.object] ||= []).push(fl.name);
+  const crowded = Object.entries(flowsPerObject).filter(([o]) => perObject[o]);
+  add('flows-and-triggers-same-object', 'adaptable', 'p3', crowded.length, crowded.map(([o, v]) => `${o}: ${perObject[o].join(', ')} + ${v.join(', ')}`));
+
+  const powerful = [...f.security.profiles, ...f.security.permissionSets].filter((p) => p.powerful.some((x) => ['ModifyAllData', 'ViewAllData'].includes(x)));
+  add('powerful-permissions', 'trusted', 'p2', powerful.length, powerful.map((p) => `${p.name} (${p.powerful.filter((x) => ['ModifyAllData', 'ViewAllData'].includes(x)).join(', ')})`));
+  const publicRW = f.data.objects.filter((o) => o.kind === 'custom' && !o.namespace && o.sharingModel === 'ReadWrite');
+  add('public-read-write-objects', 'trusted', 'p3', publicRW.length, publicRW.map((o) => o.name));
+  const insecure = f.integration.remoteSites.filter((r) => r.insecure);
+  add('insecure-remote-sites', 'trusted', 'p1', insecure.length, insecure.map((r) => r.name));
+  const legacyNc = f.integration.namedCredentials.filter((n) => n.type === 'Legacy');
+  add('legacy-named-credentials', 'trusted', 'p3', legacyNc.length, legacyNc.map((n) => n.name));
+  const fullScope = f.integration.connectedApps.filter((a) => a.scopes.includes('Full'));
+  add('connected-app-full-scope', 'trusted', 'p2', fullScope.length, fullScope.map((a) => a.name));
+  const undocumented = f.data.objects.filter((o) => o.kind === 'custom' && !o.namespace && !o.description);
+  add('objects-without-description', 'easy', 'p3', undocumented.length, undocumented.map((o) => o.name));
+  add('exclusion-candidates', 'easy', 'p3', f.exclusions.candidates.length, f.exclusions.candidates.map((c) => `${c.type} ${c.name}`));
+
+  if (codeAnalyzer) {
+    for (const [sev, n] of Object.entries(codeAnalyzer.bySeverity || {})) {
+      if (n) add(`code-analyzer-sev${sev}`, 'trusted', Number(sev) <= 2 ? 'p1' : Number(sev) === 3 ? 'p2' : 'p3', n, (codeAnalyzer.topRules || []).map((r) => `${r.rule} (${r.count})`));
+    }
+  }
+  return s;
+}