@ayurak/sdk 1.1.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
@@ -443,11 +737,35 @@ input?.addEventListener('change', async (e) => {
     PROJECT_ID: ${{ vars.PROJECT_ID }}
 ```
 
+## 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
+- **Added**: SBOM module (`client.sbom`) - document management, upload, vulnerability scanning
+- **Added**: Dashboard module (`client.dashboard`) - overview, recent activity, risk summary
+- **Added**: FinOps module (`client.finops`) - cost optimization, recommendations, cost breakdown
+- **Added**: Marketplace module (`client.marketplace`) - templates, categories, featured items
+- **Added**: API Keys module (`client.apiKeys`) - list, create, revoke API keys
+- **Added**: Framework-specific compliance scoring support
+
 ## 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/dist/index.d.mts

@@ -640,6 +640,288 @@ declare class EconomicsAPI {
     }>;
 }
 
+interface AIUsage {
+    total_requests: number;
+    tokens_used: number;
+    cost: number;
+    period: string;
+    [key: string]: unknown;
+}
+interface AIQuota {
+    requests_limit: number;
+    requests_used: number;
+    tokens_limit: number;
+    tokens_used: number;
+    reset_at: string;
+    [key: string]: unknown;
+}
+interface AIModel {
+    id: string;
+    name: string;
+    provider: string;
+    capabilities: string[];
+    [key: string]: unknown;
+}
+interface AIAnalysisResult {
+    analysis_id: string;
+    status: string;
+    results: unknown;
+    [key: string]: unknown;
+}
+interface AIQueueStatus {
+    pending: number;
+    processing: number;
+    completed: number;
+    failed: number;
+    [key: string]: unknown;
+}
+/**
+ * AI usage, quota, and analysis operations
+ */
+declare class AIAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get AI usage statistics
+     */
+    getUsage(period?: string): Promise<AIUsage>;
+    /**
+     * Get AI quota information
+     */
+    getQuota(): Promise<AIQuota>;
+    /**
+     * List available AI models
+     */
+    listModels(): Promise<AIModel[]>;
+    /**
+     * Configure AI settings
+     */
+    configure(config: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Run AI analysis
+     */
+    analyze(options: {
+        target: string;
+        type?: string;
+        model?: string;
+        [key: string]: unknown;
+    }): Promise<AIAnalysisResult>;
+    /**
+     * Get AI processing queue status
+     */
+    getQueueStatus(): Promise<AIQueueStatus>;
+}
+
+interface SBOMDocument {
+    id: string;
+    name: string;
+    format: string;
+    status: string;
+    created_at: string;
+    components_count: number;
+    vulnerabilities_count: number;
+    [key: string]: unknown;
+}
+interface SBOMVulnerability {
+    id: string;
+    cve_id: string;
+    severity: string;
+    description: string;
+    affected_component: string;
+    fix_available: boolean;
+    [key: string]: unknown;
+}
+/**
+ * SBOM document management and vulnerability scanning
+ */
+declare class SBOMAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List SBOM documents
+     */
+    list(params?: Record<string, string | number | boolean>): Promise<SBOMDocument[]>;
+    /**
+     * Get SBOM document details
+     */
+    get(documentId: string): Promise<SBOMDocument>;
+    /**
+     * Upload an SBOM document
+     */
+    upload(file: File | Blob, options?: {
+        name?: string;
+        format?: string;
+    }): Promise<SBOMDocument>;
+    /**
+     * Get vulnerabilities for an SBOM document
+     */
+    getVulnerabilities(documentId: string, params?: Record<string, string | number | boolean>): Promise<SBOMVulnerability[]>;
+}
+
+interface DashboardOverview {
+    total_diagrams: number;
+    total_threats: number;
+    compliance_score: number;
+    risk_score: number;
+    [key: string]: unknown;
+}
+interface RecentActivity {
+    id: string;
+    type: string;
+    description: string;
+    timestamp: string;
+    [key: string]: unknown;
+}
+interface RiskSummary {
+    overall_risk: string;
+    critical: number;
+    high: number;
+    medium: number;
+    low: number;
+    trend: string;
+    [key: string]: unknown;
+}
+/**
+ * Dashboard overview, activity, and risk summary
+ */
+declare class DashboardAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get dashboard overview metrics
+     */
+    getOverview(): Promise<DashboardOverview>;
+    /**
+     * Get recent activity
+     */
+    getRecentActivity(params?: Record<string, string | number | boolean>): Promise<RecentActivity[]>;
+    /**
+     * Get risk summary
+     */
+    getRiskSummary(): Promise<RiskSummary>;
+}
+
+interface FinOpsRecommendation {
+    id: string;
+    type: string;
+    description: string;
+    estimated_savings: number;
+    priority: string;
+    [key: string]: unknown;
+}
+interface FinOpsCosts {
+    total: number;
+    by_service: Record<string, number>;
+    by_provider: Record<string, number>;
+    period: string;
+    [key: string]: unknown;
+}
+interface FinOpsOptimization {
+    id: string;
+    status: string;
+    savings_achieved: number;
+    details: string;
+    [key: string]: unknown;
+}
+/**
+ * FinOps cost optimization and recommendations
+ */
+declare class FinOpsAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get cost optimization recommendations
+     */
+    getRecommendations(params?: Record<string, string | number | boolean>): Promise<FinOpsRecommendation[]>;
+    /**
+     * Get cost breakdown
+     */
+    getCosts(params?: Record<string, string | number | boolean>): Promise<FinOpsCosts>;
+    /**
+     * Get optimization details
+     */
+    getOptimization(params?: Record<string, string | number | boolean>): Promise<FinOpsOptimization[]>;
+}
+
+interface MarketplaceTemplate {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    author: string;
+    downloads: number;
+    rating: number;
+    [key: string]: unknown;
+}
+interface MarketplaceCategory {
+    id: string;
+    name: string;
+    description: string;
+    templates_count: number;
+    [key: string]: unknown;
+}
+/**
+ * Marketplace templates, categories, and featured items
+ */
+declare class MarketplaceAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List marketplace templates
+     */
+    listTemplates(params?: Record<string, string | number | boolean>): Promise<MarketplaceTemplate[]>;
+    /**
+     * List marketplace categories
+     */
+    listCategories(): Promise<MarketplaceCategory[]>;
+    /**
+     * Get featured templates
+     */
+    getFeatured(): Promise<MarketplaceTemplate[]>;
+}
+
+interface APIKey {
+    id: string;
+    name: string;
+    prefix: string;
+    created_at: string;
+    last_used_at: string | null;
+    expires_at: string | null;
+    is_active: boolean;
+    [key: string]: unknown;
+}
+interface APIKeyCreateResult {
+    id: string;
+    name: string;
+    key: string;
+    prefix: string;
+    created_at: string;
+    [key: string]: unknown;
+}
+/**
+ * API key management operations
+ */
+declare class APIKeysAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List API keys
+     */
+    list(params?: Record<string, string | number | boolean>): Promise<APIKey[]>;
+    /**
+     * Create a new API key
+     */
+    create(options: {
+        name: string;
+        expires_in_days?: number;
+        scopes?: string[];
+    }): Promise<APIKeyCreateResult>;
+    /**
+     * Revoke an API key
+     */
+    revoke(keyId: string): Promise<Record<string, unknown>>;
+}
+
 interface AribotOptions {
     baseUrl?: string;
     timeout?: number;
@@ -690,6 +972,18 @@ declare class Aribot {
     digitalTwin: DigitalTwinAPI;
     /** Economics and cost analysis */
     economics: EconomicsAPI;
+    /** AI usage and analysis */
+    ai: AIAPI;
+    /** SBOM document management */
+    sbom: SBOMAPI;
+    /** Dashboard overview and metrics */
+    dashboard: DashboardAPI;
+    /** FinOps cost optimization */
+    finops: FinOpsAPI;
+    /** Marketplace templates */
+    marketplace: MarketplaceAPI;
+    /** API key management */
+    apiKeys: APIKeysAPI;
     /**
      * Create Aribot client
      *
@@ -759,4 +1053,4 @@ declare class ServerError extends AribotError {
     constructor(message: string, statusCode?: number, response?: Record<string, unknown>);
 }
 
-export { type AnalyzeDiagramOptions, Aribot, AribotError, type AribotOptions, AuthenticationError, type CloudAccount, type CloudFinding, type CloudProvider, type CloudResource, type CloudScan, type CloudScanOptions, CloudSecurityAPI, ComplianceAPI, type ComplianceGap, type ComplianceResult, type ScanOptions$1 as ComplianceScanOptions, type ComplianceStandard, type Component, type ComponentCloudMapping, type ComponentCost, type Control, type CreateProjectOptions, type Diagram, type DiagramComponentStatus, type DiagramCostAnalysis, DigitalTwinAPI, EconomicsAPI, type EconomicsDashboard, type Finding, type GatesConfig, type GetFindingsOptions, type ListDiagramsOptions, type ListScansOptions, type MarketIntelligence, NotFoundError, PipelineAPI, type PipelineScan, type ScanOptions as PipelineScanOptions, type Project, RateLimitError, RedTeamAPI, type RedTeamMethodology, type RedTeamSimulation, ServerError, type Threat, type ThreatIntelligence, ThreatModelingAPI, ValidationError };
+export { AIAPI, type AIAnalysisResult, type AIModel, type AIQueueStatus, type AIQuota, type AIUsage, type APIKey, type APIKeyCreateResult, APIKeysAPI, type AnalyzeDiagramOptions, Aribot, AribotError, type AribotOptions, AuthenticationError, type CloudAccount, type CloudFinding, type CloudProvider, type CloudResource, type CloudScan, type CloudScanOptions, CloudSecurityAPI, ComplianceAPI, type ComplianceGap, type ComplianceResult, type ScanOptions$1 as ComplianceScanOptions, type ComplianceStandard, type Component, type ComponentCloudMapping, type ComponentCost, type Control, type CreateProjectOptions, DashboardAPI, type DashboardOverview, type Diagram, type DiagramComponentStatus, type DiagramCostAnalysis, DigitalTwinAPI, EconomicsAPI, type EconomicsDashboard, FinOpsAPI, type FinOpsCosts, type FinOpsOptimization, type FinOpsRecommendation, type Finding, type GatesConfig, type GetFindingsOptions, type ListDiagramsOptions, type ListScansOptions, type MarketIntelligence, MarketplaceAPI, type MarketplaceCategory, type MarketplaceTemplate, NotFoundError, PipelineAPI, type PipelineScan, type ScanOptions as PipelineScanOptions, type Project, RateLimitError, type RecentActivity, RedTeamAPI, type RedTeamMethodology, type RedTeamSimulation, type RiskSummary, SBOMAPI, type SBOMDocument, type SBOMVulnerability, ServerError, type Threat, type ThreatIntelligence, ThreatModelingAPI, ValidationError };