tryassay 0.1.2 → 0.3.0

package/dist/runtime/types.d.ts

@@ -0,0 +1,321 @@
+export type SignalSourceType = 'filesystem' | 'webhook' | 'schedule' | 'message' | 'api_poll';
+export interface FileSystemSignalConfig {
+    type: 'filesystem';
+    paths: string[];
+    patterns?: string[];
+    ignorePatterns?: string[];
+}
+export interface WebhookSignalConfig {
+    type: 'webhook';
+    port: number;
+    path: string;
+    secret?: string;
+}
+export interface ScheduleSignalConfig {
+    type: 'schedule';
+    intervalMs: number;
+    label: string;
+}
+export interface MessageSignalConfig {
+    type: 'message';
+    channel: string;
+}
+export interface ApiPollSignalConfig {
+    type: 'api_poll';
+    url: string;
+    intervalMs: number;
+    headers?: Record<string, string>;
+}
+export type SignalConfig = FileSystemSignalConfig | WebhookSignalConfig | ScheduleSignalConfig | MessageSignalConfig | ApiPollSignalConfig;
+export type ObservationUrgency = 'critical' | 'high' | 'normal' | 'low';
+export interface Observation {
+    id: string;
+    source: SignalSourceType;
+    urgency: ObservationUrgency;
+    timestamp: string;
+    payload: ObservationPayload;
+    relatedExperienceIds?: string[];
+}
+export type ObservationPayload = FileChangePayload | WebhookPayload | ScheduleTickPayload | MessagePayload | ApiPollPayload;
+export interface FileChangePayload {
+    type: 'file_change';
+    event: 'create' | 'modify' | 'delete';
+    path: string;
+    diff?: string;
+}
+export interface WebhookPayload {
+    type: 'webhook';
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    body: unknown;
+}
+export interface ScheduleTickPayload {
+    type: 'schedule_tick';
+    label: string;
+    tickNumber: number;
+}
+export interface MessagePayload {
+    type: 'message';
+    channel: string;
+    sender: string;
+    content: string;
+}
+export interface ApiPollPayload {
+    type: 'api_poll';
+    url: string;
+    statusCode: number;
+    body: unknown;
+    previousBody?: unknown;
+}
+export type DecisionAction = 'act' | 'ignore' | 'defer';
+export interface Decision {
+    id: string;
+    observationId: string;
+    action: DecisionAction;
+    reasoning: string;
+    confidence: number;
+    proposedActions: ProposedAction[];
+    risks: string[];
+    modelUsage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    timestamp: string;
+}
+export interface ProposedAction {
+    description: string;
+    operationType: OperationType;
+    target: string;
+    details: string;
+}
+export type OperationType = 'code_write' | 'code_run' | 'api_call' | 'git' | 'message';
+export type ApprovalLevel = 'auto' | 'single' | 'escalate';
+export interface ActionPlan {
+    id: string;
+    decisionId: string;
+    steps: ActionStep[];
+    totalSteps: number;
+    estimatedDurationMs: number;
+    overallRisk: ApprovalLevel;
+    timestamp: string;
+}
+export interface ActionStep {
+    id: string;
+    planId: string;
+    index: number;
+    description: string;
+    operation: Operation;
+    preConditions: Condition[];
+    postConditions: Condition[];
+    approvalLevel: ApprovalLevel;
+    dependsOn: string[];
+}
+export interface Condition {
+    description: string;
+    check: string;
+}
+export type Operation = CodeWriteOp | CodeRunOp | ApiCallOp | GitOp | MessageOp;
+export interface CodeWriteOp {
+    type: 'code_write';
+    filePath: string;
+    content: string;
+    mode: 'create' | 'edit' | 'append';
+    editTarget?: string;
+}
+export interface CodeRunOp {
+    type: 'code_run';
+    command: string;
+    cwd?: string;
+    timeoutMs: number;
+    env?: Record<string, string>;
+}
+export interface ApiCallOp {
+    type: 'api_call';
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    expectedStatus?: number;
+}
+export interface GitOp {
+    type: 'git';
+    command: 'add' | 'commit' | 'push' | 'branch' | 'checkout';
+    args: string[];
+    cwd?: string;
+}
+export interface MessageOp {
+    type: 'message';
+    channel: 'console' | 'slack' | 'email';
+    recipient?: string;
+    subject?: string;
+    content: string;
+}
+export type VerificationVerdict = 'pass' | 'warn' | 'fail' | 'escalate';
+export interface StepVerification {
+    stepId: string;
+    verdict: VerificationVerdict;
+    claims: VerificationClaim[];
+    reasoning: string;
+    formalOverrides: number;
+    timestamp: string;
+}
+export interface VerificationClaim {
+    id: string;
+    text: string;
+    verdict: 'PASS' | 'PARTIAL' | 'FAIL' | 'N/A';
+    confidence: number;
+    method: 'formal' | 'llm';
+}
+export interface PlanVerification {
+    planId: string;
+    overallVerdict: VerificationVerdict;
+    stepVerifications: StepVerification[];
+    blockedSteps: string[];
+    escalatedSteps: string[];
+    totalClaims: number;
+    passedClaims: number;
+    failedClaims: number;
+    timestamp: string;
+}
+export type ExecutionStatus = 'success' | 'partial' | 'failure' | 'skipped';
+export interface StepExecution {
+    stepId: string;
+    status: ExecutionStatus;
+    output: string;
+    error?: string;
+    durationMs: number;
+    timestamp: string;
+}
+export interface PlanExecution {
+    planId: string;
+    status: ExecutionStatus;
+    stepExecutions: StepExecution[];
+    completedSteps: number;
+    totalSteps: number;
+    totalDurationMs: number;
+    timestamp: string;
+}
+export type ExperienceOutcome = 'success' | 'partial_success' | 'failure' | 'unexpected';
+export interface Experience {
+    id: string;
+    observation: Observation;
+    decision: Decision;
+    plan: ActionPlan;
+    verification: PlanVerification;
+    execution: PlanExecution;
+    outcome: ExperienceOutcome;
+    delta: string;
+    lessons: string[];
+    domain: string;
+    tags: string[];
+    timestamp: string;
+}
+export interface SkillProfile {
+    domain: string;
+    totalExperiences: number;
+    successRate: number;
+    firstPassRate: number;
+    commonPatterns: string[];
+    commonAntiPatterns: string[];
+    lastUpdated: string;
+}
+export interface PatternEntry {
+    id: string;
+    domain: string;
+    description: string;
+    codeExample: string;
+    language: string;
+    verificationCount: number;
+    lastVerified: string;
+    formallyVerified: boolean;
+}
+export interface AntiPatternEntry {
+    id: string;
+    domain: string;
+    description: string;
+    badExample: string;
+    fixedExample: string;
+    language: string;
+    claimCategory: string;
+    occurrenceCount: number;
+    lastSeen: string;
+}
+export interface AgentScope {
+    allowedDirectories: string[];
+    allowedCommands: string[];
+    allowedUrls: string[];
+    blockedPatterns: string[];
+    maxFileSize: number;
+}
+export interface HardLimits {
+    maxActionsPerHour: number;
+    maxTokensPerHour: number;
+    maxConcurrentSteps: number;
+    maxPlanSteps: number;
+    commandTimeoutMs: number;
+    maxSessionCostCents?: number;
+}
+export interface AgentConfig {
+    name: string;
+    description: string;
+    scope: AgentScope;
+    limits: HardLimits;
+    signals: SignalConfig[];
+    approvalDefaults: Record<OperationType, ApprovalLevel>;
+    modelId: string;
+    experienceStorePath: string;
+    controlPort?: number;
+    jsonLogs?: boolean;
+}
+export type AgentPhase = 'idle' | 'observing' | 'reasoning' | 'planning' | 'verifying' | 'awaiting_approval' | 'executing' | 'reflecting' | 'paused' | 'stopped';
+export interface AgentState {
+    phase: AgentPhase;
+    currentObservation: Observation | null;
+    currentDecision: Decision | null;
+    currentPlan: ActionPlan | null;
+    queueDepth: number;
+    actionsThisHour: number;
+    tokensThisHour: number;
+    totalExperiences: number;
+    uptime: number;
+    lastActivityTimestamp: string;
+    errors: AgentError[];
+}
+export interface AgentError {
+    phase: AgentPhase;
+    message: string;
+    timestamp: string;
+    recoverable: boolean;
+}
+export type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
+export interface ApprovalRequest {
+    id: string;
+    planId: string;
+    stepId?: string;
+    action: string;
+    reasoning: string;
+    riskLevel: ApprovalLevel;
+    verification: PlanVerification;
+    status: ApprovalStatus;
+    createdAt: string;
+    resolvedAt?: string;
+    resolvedBy?: string;
+    rejectionReason?: string;
+}
+export type AuditEventType = 'observation_received' | 'decision_made' | 'plan_created' | 'verification_completed' | 'approval_requested' | 'approval_resolved' | 'step_executed' | 'experience_stored' | 'agent_started' | 'agent_stopped' | 'agent_error';
+export interface AuditEntry {
+    id: string;
+    eventType: AuditEventType;
+    agentName: string;
+    timestamp: string;
+    details: Record<string, unknown>;
+    relatedIds: {
+        observationId?: string;
+        decisionId?: string;
+        planId?: string;
+        stepId?: string;
+        experienceId?: string;
+    };
+    prevHash?: string;
+}

package/dist/runtime/types.js

@@ -0,0 +1,6 @@
+// ============================================================
+// Assay Verified Agent Runtime — Core Types
+// Phase 1 + Phase 2 foundations
+// ============================================================
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runtime/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/runtime/types.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,4CAA4C;AAC5C,gCAAgC;AAChC,+DAA+D"}

package/dist/runtime/verifier.d.ts

@@ -0,0 +1,46 @@
+import type { ActionPlan, ActionStep, AgentConfig, PlanExecution, PlanVerification, StepVerification } from './types.js';
+export declare class RuntimeVerifier {
+    private config;
+    private cachedIndex;
+    constructor(config: AgentConfig);
+    /**
+     * Verify an entire action plan before execution.
+     * Returns a PlanVerification with per-step results and an aggregate verdict.
+     */
+    verifyPlan(plan: ActionPlan): Promise<PlanVerification>;
+    /**
+     * Verify a single action step.
+     * Routes to the appropriate verification strategy based on operation type.
+     */
+    verifyStep(step: ActionStep): Promise<StepVerification>;
+    /**
+     * Post-execution verification: compare actual outcomes to planned postConditions.
+     * Returns a PlanVerification reflecting what actually happened.
+     */
+    verifyPostExecution(plan: ActionPlan, execution: PlanExecution): Promise<PlanVerification>;
+    /**
+     * Verify a code_write step by running the code through Assay's
+     * claim extraction + verification pipeline.
+     */
+    private verifyCodeWrite;
+    /**
+     * Verify a code_run step by checking the command and cwd against scope.
+     */
+    private verifyCodeRun;
+    /**
+     * Verify an api_call step by checking the URL against scope.
+     */
+    private verifyApiCall;
+    /**
+     * Verify a git step — always pass. Git operations are safe and reversible.
+     */
+    private verifyGit;
+    /**
+     * Verify a message step — always pass. Messages are informational.
+     */
+    private verifyMessage;
+    private getCodebaseIndex;
+    /** Invalidate the cached codebase index (call after code changes). */
+    invalidateIndex(): void;
+    private makeStepVerification;
+}