@ayurak/sdk 1.4.0 → 1.5.0

package/README.md

@@ -277,8 +277,16 @@ console.log(`Monthly cost: $${cost.total_monthly_cost}`);
 // Get component cost
 const componentCost = await client.economics.getComponentCost(componentId);
 
-// Get economic intelligence
+// Get economic intelligence (includes Strategic Cost Optimization)
 const intel = await client.economics.getEconomicIntelligence();
+// Returns: { status: 'success', provider: 'aws', pricing: {...},
+//           strategic_optimization: { current: {...}, previous: {...} } }
+
+// Refresh Strategic Cost Optimization recommendations (AI-powered)
+// Moves current recommendations to "previous" and generates new ones
+const refresh = await client.economics.refreshRecommendations();
+// Returns: { status: 'success', message: 'Recommendations refreshed',
+//           current: {...}, previous: {...} }
 
 // Get market intelligence
 const market = await client.economics.getMarketIntelligence();
@@ -315,6 +323,292 @@ const paths = await client.redTeam.generateAttackPaths(diagramId, {
 const requirements = await client.redTeam.getSecurityRequirements(diagramId);
 ```
 
+### Severity Assignment (AI-powered)
+
+```typescript
+// Estimate AI cost for severity assignment
+const estimate = await client.compliance.estimateSeverityCost({
+  scanId: scanId,
+  accountId: accountId
+});
+// Returns: { estimated_tokens: 15000, estimated_cost_usd: 0.45, violations_count: 150 }
+
+// Assign severity using AI (automatically analyzes all violations)
+const result = await client.compliance.assignSeverityAI({
+  scanId: scanId,
+  accountId: accountId,
+  model: 'claude-3-sonnet', // or 'gpt-4', 'gemini-pro'
+  batchSize: 50
+});
+// Returns: { status: 'completed', processed: 150, updated: 142, errors: 0 }
+
+// Manually assign severity to violations
+const manualResult = await client.compliance.assignSeverityManual({
+  violationIds: ['v-123', 'v-456'],
+  severity: 'high' // critical, high, medium, low, info
+});
+// Returns: { updated: 2, violations: [...] }
+```
+
+### Scanner Rules
+
+```typescript
+// List scanner rules
+const rules = await client.compliance.listScannerRules({
+  severity: 'critical',
+  provider: 'aws'
+});
+// Returns: [{ id: '...', name: 'S3 Public Access', severity: 'critical' }, ...]
+
+// Get scanner rule statistics
+const stats = await client.compliance.getScannerStatistics();
+// Returns: { total_rules: 500, by_severity: {...}, by_provider: {...} }
+
+// Sync rules from cloud providers
+const syncResult = await client.compliance.syncScannerRules({
+  providers: ['aws', 'azure', 'gcp']
+});
+// Returns: { synced: 150, new: 25, updated: 10 }
+
+// Create custom scanner rule
+const rule = await client.compliance.createScannerRule({
+  name: 'Custom S3 Encryption Check',
+  description: 'Ensure all S3 buckets have encryption enabled',
+  severity: 'high',
+  provider: 'aws',
+  resourceType: 's3_bucket',
+  condition: {
+    field: 'encryption.enabled',
+    operator: 'equals',
+    value: true
+  }
+});
+```
+
+### Dynamic Cloud Scanning
+
+```typescript
+// Execute dynamic scan on cloud account
+const scan = await client.compliance.executeDynamicScan({
+  accountId: accountId,
+  scanType: 'full', // full, quick, targeted
+  resources: ['ec2', 's3', 'iam'],
+  standards: ['CIS-AWS', 'SOC2']
+});
+// Returns: { scan_id: '...', status: 'running', estimated_duration: 300 }
+
+// Execute unified scan with flexible scope
+const unifiedScan = await client.compliance.executeUnifiedScan({
+  scope: 'account', // account, standard, diagram
+  scopeId: accountId,
+  includeRemediation: true
+});
+// Returns: { scan_id: '...', status: 'queued' }
+```
+
+### Remediation Execution
+
+```typescript
+// Preview remediation before execution
+const preview = await client.compliance.previewRemediation({
+  policyId: policyId,
+  accountId: accountId
+});
+// Returns: { actions: [...], risk_level: 'low', affected_resources: 5 }
+
+// Execute remediation
+const result = await client.compliance.executeRemediation({
+  policyId: policyId,
+  accountId: accountId,
+  dryRun: false,
+  autoApprove: true
+});
+// Returns: { status: 'completed', resources_fixed: 5, rollback_available: true }
+```
+
+### AI Agents & Self-Healing
+
+```typescript
+// Get AI agent status
+const status = await client.aiAgents.getStatus();
+// Returns: { active: true, agents: [...], capabilities: [...] }
+
+// Run specialist agent analysis
+const analysis = await client.aiAgents.runSpecialist({
+  agentType: 'security', // security, compliance, cost, architecture
+  diagramId: diagramId
+});
+
+// Self-healing operations
+const healingStatus = await client.aiAgents.getSelfHealingStatus();
+// Returns: { enabled: true, recent_actions: [...], autonomy_level: 'supervised' }
+
+// Get autonomy stats
+const autonomyStats = await client.aiAgents.getAutonomyStats();
+// Returns: { total_remediations: 150, auto_approved: 120, manual_review: 30 }
+
+// Trigger remediation
+const remediation = await client.aiAgents.triggerRemediation({
+  findingId: findingId,
+  autoApprove: false
+});
+
+// Approve/reject remediation action
+await client.aiAgents.approveRemediation(remediationId);
+await client.aiAgents.rejectRemediation(remediationId, 'Risk too high');
+
+// Rollback remediation
+await client.aiAgents.rollbackRemediation(remediationId);
+
+// Emergency stop all autonomous actions
+await client.aiAgents.emergencyStop();
+
+// Resume autonomous operations
+await client.aiAgents.resumeOperations();
+```
+
+### Security Co-Pilot
+
+```typescript
+// Get security co-pilot status
+const status = await client.securityCopilot.getStatus();
+// Returns: { enabled: true, mode: 'supervised', active_threats: 5 }
+
+// Get pending actions awaiting approval
+const actions = await client.securityCopilot.getPendingActions();
+// Returns: [{ id: '...', type: 'patch', resource: '...', risk: 'low' }, ...]
+
+// Get action history
+const history = await client.securityCopilot.getActionHistory({ limit: 50 });
+
+// Get active threats
+const threats = await client.securityCopilot.getActiveThreats();
+
+// Approve/reject action
+await client.securityCopilot.approveAction(actionId);
+await client.securityCopilot.rejectAction(actionId);
+
+// Rollback action
+await client.securityCopilot.rollbackAction(actionId);
+
+// Trigger security scan
+const scan = await client.securityCopilot.triggerScan({ scope: 'full' });
+
+// Update settings
+await client.securityCopilot.updateSettings({
+  autoRemediation: true,
+  maxRiskLevel: 'medium'
+});
+
+// Toggle co-pilot on/off
+await client.securityCopilot.toggle(true);
+```
+
+### Presets Import
+
+```typescript
+// Import compliance presets
+const presets = await client.compliance.importPresets({
+  provider: 'aws', // aws, azure, gcp, all
+  categories: ['security', 'cost', 'operations']
+});
+// Returns: { imported: 50, standards: [...], rules: [...] }
+```
+
+### Strategic Remediation Plan (AI-powered)
+
+```typescript
+// Generate strategic remediation plan for a severity level
+// Uses AI to analyze all violations and create a comprehensive plan
+const plan = await client.compliance.generateStrategicPlan({
+  scanId: scanId,
+  accountId: accountId,
+  severity: 'critical' // critical, high, medium, low
+});
+// Returns: {
+//   id: 'uuid',
+//   severity: 'critical',
+//   status: 'generated',
+//   overview: 'Strategic overview of all critical violations...',
+//   rootCauses: [{ cause: '...', theme: '...', impact: '...' }],
+//   groupedViolations: [{ policy: '...', violations: [...] }],
+//   highImpactActions: [{ action: '...', impactScore: 95 }],
+//   remediationPhases: [{ phase: 1, duration: '1 week', actions: [...] }],
+//   successMetrics: [{ metric: '...', target: '...' }],
+//   estimatedTotalEffort: '2-3 weeks',
+//   costSavingsFinops: { monthly: 5000, annual: 60000 },
+//   costSavingsRisk: { riskReduction: '85%', avoidedIncidents: 12 }
+// }
+
+// Get existing strategic plan
+const existing = await client.compliance.getStrategicPlan(planId);
+
+// List strategic plans for an account
+const plans = await client.compliance.listStrategicPlans({
+  accountId: accountId,
+  severity: 'critical'
+});
+```
+
+### Mitigation Plan (AI-powered)
+
+```typescript
+// Get existing mitigation plan for a diagram
+const plan = await client.threatModeling.getMitigationPlan(diagramId);
+if (plan) {
+  console.log(`Overview: ${plan.plan.overview}`);
+  console.log(`Recommendations: ${plan.plan.recommendations.length}`);
+  plan.plan.recommendations.forEach(rec => {
+    console.log(`  [${rec.rank}] ${rec.title} - ${rec.priority}`);
+  });
+}
+
+// Generate new mitigation plan (AI-powered, uses chunked processing)
+const newPlan = await client.threatModeling.generateMitigationPlan(diagramId, {
+  forceRegenerate: true  // Force regenerate even if cached
+});
+// Returns comprehensive plan with:
+// - overview: Strategic summary of all threats
+// - recommendations: Ranked list with code snippets
+// - rootCauses: Identified patterns across threats
+// - remediationPhases: Phased approach with timelines
+// - successMetrics: Measurable criteria
+// - metadata: AI provider, generation time, etc.
+
+console.log(`Generated in ${newPlan.plan.metadata.generationTimeMs}ms`);
+console.log(`Threats analyzed: ${newPlan.plan.metadata.threatCount}`);
+
+// Access recommendations with code snippets
+newPlan.plan.recommendations.forEach(rec => {
+  console.log(`[${rec.priority}] ${rec.title}`);
+  console.log(`  Impact: ${rec.impact}`);
+  console.log(`  Effort: ${rec.effort}`);
+  console.log(`  Affected threats: ${rec.affectedThreats?.join(', ')}`);
+  if (rec.codeSnippet) {
+    console.log(`  Code (${rec.codeLanguage}):`);
+    console.log(`    ${rec.codeSnippet}`);
+  }
+});
+
+// View root causes (patterns identified across multiple threats)
+newPlan.plan.rootCauses.forEach(cause => {
+  console.log(`Root cause: ${cause.cause}`);
+  console.log(`  Theme: ${cause.theme}, Impact: ${cause.impact}`);
+});
+
+// View phased remediation plan
+newPlan.plan.remediationPhases.forEach(phase => {
+  console.log(`Phase: ${phase.phase} (${phase.duration})`);
+  console.log(`  Actions: ${phase.actions.join(', ')}`);
+  console.log(`  Threats resolved: ${phase.threatsResolved}`);
+});
+
+// Update plan with manual edits
+const updatedPlan = { ...newPlan.plan };
+updatedPlan.recommendations[0].priority = 'immediate';
+await client.threatModeling.updateMitigationPlan(diagramId, updatedPlan);
+```
+
 ## Error Handling
 
 ```typescript
@@ -445,6 +739,18 @@ input?.addEventListener('change', async (e) => {
 
 ## Changelog
 
+### v1.5.0
+- **Added**: Strategic Remediation Plan API (`client.compliance.generateStrategicPlan`, `getStrategicPlan`, `listStrategicPlans`) - AI-powered strategic planning for compliance violations with cost savings analysis
+- **Added**: Economic Intelligence Refresh (`client.economics.refreshRecommendations`) - Refresh AI-powered cost optimization recommendations
+- **Added**: Severity Assignment API (`client.compliance.estimateSeverityCost`, `assignSeverityAI`, `assignSeverityManual`)
+- **Added**: Scanner Rules API (`client.compliance.listScannerRules`, `getScannerStatistics`, `syncScannerRules`, `createScannerRule`)
+- **Added**: Dynamic Cloud Scanning (`client.compliance.executeDynamicScan`, `executeUnifiedScan`)
+- **Added**: Remediation Execution (`client.compliance.previewRemediation`, `executeRemediation`)
+- **Added**: AI Agents & Self-Healing module (`client.aiAgents`) with autonomous remediation
+- **Added**: Security Co-Pilot module (`client.securityCopilot`) for supervised security operations
+- **Added**: Presets Import (`client.compliance.importPresets`)
+- **Added**: Mitigation Plan API (`client.threatModeling.getMitigationPlan`, `generateMitigationPlan`, `updateMitigationPlan`) - AI-powered strategic remediation planning with chunked processing
+
 ### v1.4.0
 - **Fixed**: Base URL corrected from `api.aribot.aristiun.com` to `api.aribot.ayurak.com`
 - **Added**: AI module (`client.ai`) - usage, quota, models, configure, analyze, queue status
@@ -457,9 +763,9 @@ input?.addEventListener('change', async (e) => {
 
 ## Support
 
-- Documentation: https://developers.aristiun.com/docs/js-sdk
-- API Reference: https://developers.aristiun.com/api
-- Issues: https://github.com/Aristiun/aribot-js/issues
+- Documentation: https://developer.ayurak.com/docs/js-sdk
+- API Reference: https://developer.ayurak.com/api
+- Issues: https://github.com/ayurak/aribot-js/issues
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ayurak/sdk",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Aribot Security Platform SDK by Aristiun & Ayurak - Threat modeling, compliance, and cloud security APIs",
   "main": "dist/index.js",
   "module": "dist/index.mjs",