scene-capability-engine 3.6.65 → 3.6.67

package/lib/semantic/supreme-intent-report.js

@@ -0,0 +1,300 @@
+const { getSceStateStore } = require('../state/sce-state-store');
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeInteger(value, fallback = 0) {
+  const parsed = Number.parseInt(`${value}`, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function percent(part, total) {
+  if (!Number.isFinite(part) || !Number.isFinite(total) || total <= 0) {
+    return 0;
+  }
+  return Number(((part / total) * 100).toFixed(2));
+}
+
+function incrementCounter(map, key, amount = 1) {
+  if (!key) {
+    return;
+  }
+  map[key] = (map[key] || 0) + amount;
+}
+
+function countBy(items = [], getKey) {
+  const totals = {};
+  for (const item of items) {
+    const key = normalizeString(getKey(item));
+    incrementCounter(totals, key || 'unknown');
+  }
+  return Object.entries(totals)
+    .map(([key, count]) => ({ key, count }))
+    .sort((left, right) => {
+      if (right.count !== left.count) {
+        return right.count - left.count;
+      }
+      return left.key.localeCompare(right.key);
+    });
+}
+
+function listMatchedRuleIds(matchedRules = {}) {
+  const ids = new Set();
+  if (!matchedRules || typeof matchedRules !== 'object') {
+    return [];
+  }
+  for (const value of Object.values(matchedRules)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === 'object') {
+          const id = normalizeString(item.id || item.rule_id || item.ruleId);
+          if (id) {
+            ids.add(id);
+          }
+        }
+      }
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      const id = normalizeString(value.id || value.rule_id || value.ruleId);
+      if (id) {
+        ids.add(id);
+      }
+    }
+  }
+  return [...ids].sort((left, right) => left.localeCompare(right));
+}
+
+function rankGroupedItems(items = [], hotspotLimit = 5) {
+  return items
+    .sort((left, right) => {
+      if (right.governed_count !== left.governed_count) {
+        return right.governed_count - left.governed_count;
+      }
+      if (right.total !== left.total) {
+        return right.total - left.total;
+      }
+      return `${right.latest_at || ''}`.localeCompare(`${left.latest_at || ''}`);
+    })
+    .slice(0, hotspotLimit);
+}
+
+function buildScopeHotspots(items = [], hotspotLimit = 5) {
+  const scopes = new Map();
+  for (const item of items) {
+    const key = [
+      normalizeString(item.project_id) || 'project:none',
+      normalizeString(item.channel_id) || 'channel:none',
+      normalizeString(item.scene_id) || 'scene:none',
+      normalizeString(item.spec_id) || 'spec:none'
+    ].join('::');
+    if (!scopes.has(key)) {
+      scopes.set(key, {
+        project_id: normalizeString(item.project_id) || null,
+        channel_id: normalizeString(item.channel_id) || null,
+        scene_id: normalizeString(item.scene_id) || null,
+        spec_id: normalizeString(item.spec_id) || null,
+        total: 0,
+        allow: 0,
+        clarify: 0,
+        rewrite: 0,
+        narrow: 0,
+        refuse: 0,
+        governed_count: 0,
+        latest_at: null
+      });
+    }
+    const scope = scopes.get(key);
+    const action = normalizeString(item.action) || 'unknown';
+    scope.total += 1;
+    if (Object.prototype.hasOwnProperty.call(scope, action)) {
+      scope[action] += 1;
+    }
+    if (action !== 'allow') {
+      scope.governed_count += 1;
+    }
+    const updatedAt = normalizeString(item.updated_at) || null;
+    if (!scope.latest_at || `${updatedAt || ''}` > `${scope.latest_at || ''}`) {
+      scope.latest_at = updatedAt;
+    }
+  }
+  return rankGroupedItems([...scopes.values()], hotspotLimit);
+}
+
+function buildMatchedRuleHotspots(items = [], hotspotLimit = 5) {
+  const rules = new Map();
+  for (const item of items) {
+    const ruleIds = listMatchedRuleIds(item.matched_rules);
+    for (const ruleId of ruleIds) {
+      if (!rules.has(ruleId)) {
+        rules.set(ruleId, {
+          rule_id: ruleId,
+          count: 0,
+          actions: {},
+          sources: {},
+          latest_at: null
+        });
+      }
+      const record = rules.get(ruleId);
+      const action = normalizeString(item.action) || 'unknown';
+      const sourceKind = normalizeString(item.source_kind) || 'unknown';
+      record.count += 1;
+      incrementCounter(record.actions, action);
+      incrementCounter(record.sources, sourceKind);
+      const updatedAt = normalizeString(item.updated_at) || null;
+      if (!record.latest_at || `${updatedAt || ''}` > `${record.latest_at || ''}`) {
+        record.latest_at = updatedAt;
+      }
+    }
+  }
+  return [...rules.values()]
+    .sort((left, right) => {
+      if (right.count !== left.count) {
+        return right.count - left.count;
+      }
+      return `${right.latest_at || ''}`.localeCompare(`${left.latest_at || ''}`);
+    })
+    .slice(0, hotspotLimit)
+    .map((item) => ({
+      ...item,
+      actions: countBy(
+        Object.entries(item.actions).map(([key, count]) => ({ key, count })),
+        (entry) => entry.key
+      ).map((entry) => ({ action: entry.key, count: item.actions[entry.key] || entry.count })),
+      sources: countBy(
+        Object.entries(item.sources).map(([key, count]) => ({ key, count })),
+        (entry) => entry.key
+      ).map((entry) => ({ source_kind: entry.key, count: item.sources[entry.key] || entry.count }))
+    }));
+}
+
+function summarizeRecentItems(items = [], recentLimit = 10, actionFilter = '') {
+  const normalizedAction = normalizeString(actionFilter);
+  return items
+    .filter((item) => !normalizedAction || normalizeString(item.action) === normalizedAction)
+    .sort((left, right) => `${right.updated_at || ''}`.localeCompare(`${left.updated_at || ''}`))
+    .slice(0, recentLimit)
+    .map((item) => ({
+      assessment_id: item.assessment_id,
+      project_id: item.project_id,
+      channel_id: item.channel_id,
+      session_id: item.session_id,
+      scene_id: item.scene_id,
+      spec_id: item.spec_id,
+      job_id: item.job_id,
+      source_kind: item.source_kind,
+      action: item.action,
+      planning_allowed: item.planning_allowed,
+      execution_allowed: item.execution_allowed,
+      message: item.message,
+      matched_rule_ids: listMatchedRuleIds(item.matched_rules),
+      updated_at: item.updated_at
+    }));
+}
+
+async function buildSupremeIntentGovernanceReport(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const store = dependencies.stateStore || getSceStateStore(projectPath, {
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule,
+    noCache: dependencies.noCache === true
+  });
+  const scanLimit = normalizeInteger(options.limit, 200);
+  const hotspotLimit = normalizeInteger(options.hotspot_limit || options.hotspotLimit, 5);
+  const recentLimit = normalizeInteger(options.recent_limit || options.recentLimit, 10);
+
+  let items = await store.listSupremeIntentAssessments({
+    project_id: options.project_id || options.projectId,
+    channel_id: options.channel_id || options.channelId,
+    session_id: options.session_id || options.sessionId,
+    scene_id: options.scene_id || options.sceneId,
+    spec_id: options.spec_id || options.specId,
+    job_id: options.job_id || options.jobId,
+    source_kind: options.source_kind || options.sourceKind,
+    action: options.action,
+    limit: scanLimit
+  });
+  items = Array.isArray(items) ? items : [];
+
+  const governedItems = items.filter((item) => normalizeString(item.action) && normalizeString(item.action) !== 'allow');
+  const planningBlocked = items.filter((item) => item.planning_allowed !== true);
+  const executionBlocked = items.filter((item) => item.execution_allowed !== true);
+
+  return {
+    mode: 'semantic-governance-report',
+    success: true,
+    generated_at: new Date().toISOString(),
+    filters: {
+      project_id: normalizeString(options.project_id || options.projectId) || null,
+      channel_id: normalizeString(options.channel_id || options.channelId) || null,
+      session_id: normalizeString(options.session_id || options.sessionId) || null,
+      scene_id: normalizeString(options.scene_id || options.sceneId) || null,
+      spec_id: normalizeString(options.spec_id || options.specId) || null,
+      job_id: normalizeString(options.job_id || options.jobId) || null,
+      source_kind: normalizeString(options.source_kind || options.sourceKind) || null,
+      action: normalizeString(options.action) || null,
+      limit: scanLimit,
+      hotspot_limit: hotspotLimit,
+      recent_limit: recentLimit
+    },
+    totals: {
+      total: items.length,
+      governed: governedItems.length,
+      allow: items.filter((item) => normalizeString(item.action) === 'allow').length,
+      clarify: items.filter((item) => normalizeString(item.action) === 'clarify').length,
+      rewrite: items.filter((item) => normalizeString(item.action) === 'rewrite').length,
+      narrow: items.filter((item) => normalizeString(item.action) === 'narrow').length,
+      refuse: items.filter((item) => normalizeString(item.action) === 'refuse').length,
+      planning_blocked: planningBlocked.length,
+      execution_blocked: executionBlocked.length,
+      governed_action_rate_percent: percent(governedItems.length, items.length)
+    },
+    top_actions: countBy(items, (item) => item.action)
+      .slice(0, hotspotLimit)
+      .map((item) => ({ action: item.key, count: item.count })),
+    top_sources: countBy(items, (item) => item.source_kind)
+      .slice(0, hotspotLimit)
+      .map((item) => ({ source_kind: item.key, count: item.count })),
+    top_projects: countBy(governedItems, (item) => item.project_id)
+      .slice(0, hotspotLimit)
+      .map((item) => ({ project_id: item.key === 'unknown' ? null : item.key, count: item.count })),
+    top_channels: countBy(governedItems, (item) => `${normalizeString(item.project_id) || 'unknown'}::${normalizeString(item.channel_id) || 'none'}`)
+      .slice(0, hotspotLimit)
+      .map((item) => {
+        const [projectId, channelId] = item.key.split('::');
+        return {
+          project_id: projectId === 'unknown' ? null : projectId,
+          channel_id: channelId === 'none' ? null : channelId,
+          count: item.count
+        };
+      }),
+    top_specs: countBy(governedItems, (item) => `${normalizeString(item.project_id) || 'unknown'}::${normalizeString(item.spec_id) || 'none'}`)
+      .slice(0, hotspotLimit)
+      .map((item) => {
+        const [projectId, specId] = item.key.split('::');
+        return {
+          project_id: projectId === 'unknown' ? null : projectId,
+          spec_id: specId === 'none' ? null : specId,
+          count: item.count
+        };
+      }),
+    top_scope_hotspots: buildScopeHotspots(governedItems, hotspotLimit),
+    top_matched_rules: buildMatchedRuleHotspots(governedItems, hotspotLimit),
+    recent_governed_items: summarizeRecentItems(governedItems, recentLimit),
+    recent_refusals: summarizeRecentItems(governedItems, recentLimit, 'refuse'),
+    recent_rewrites: summarizeRecentItems(governedItems, recentLimit, 'rewrite')
+  };
+}
+
+module.exports = {
+  buildSupremeIntentGovernanceReport,
+  listMatchedRuleIds
+};