circle-ir 3.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,392 @@
+/**
+ * Circle-IR 3.0 TypeScript Type Definitions
+ *
+ * These types conform to docs/SPEC.md
+ */
+export type SupportedLanguage = "java" | "c" | "cpp" | "javascript" | "typescript" | "python" | "rust";
+export interface Meta {
+    circle_ir: "3.0";
+    file: string;
+    language: SupportedLanguage;
+    loc: number;
+    hash: string;
+    package?: string;
+}
+export interface TypeInfo {
+    name: string;
+    kind: "class" | "interface" | "enum";
+    package: string | null;
+    extends: string | null;
+    implements: string[];
+    annotations: string[];
+    methods: MethodInfo[];
+    fields: FieldInfo[];
+    start_line: number;
+    end_line: number;
+}
+export interface MethodInfo {
+    name: string;
+    return_type: string | null;
+    parameters: ParameterInfo[];
+    annotations: string[];
+    modifiers: string[];
+    start_line: number;
+    end_line: number;
+}
+export interface ParameterInfo {
+    name: string;
+    type: string | null;
+    annotations: string[];
+    line?: number;
+}
+export interface FieldInfo {
+    name: string;
+    type: string | null;
+    modifiers: string[];
+    annotations: string[];
+}
+export interface CallInfo {
+    method_name: string;
+    receiver: string | null;
+    receiver_type?: string | null;
+    arguments: ArgumentInfo[];
+    location: {
+        line: number;
+        column: number;
+    };
+    in_method?: string | null;
+    is_constructor?: boolean;
+    resolved?: boolean;
+    resolution?: CallResolution;
+}
+export interface ArgumentInfo {
+    position: number;
+    expression: string;
+    variable?: string | null;
+    literal?: string | null;
+    value?: string | null;
+}
+export interface CallResolution {
+    status: "resolved" | "external_method" | "interface_method" | "reflection";
+    target?: string;
+    candidates?: string[];
+}
+export interface CFG {
+    blocks: CFGBlock[];
+    edges: CFGEdge[];
+}
+export interface CFGBlock {
+    id: number;
+    type: "entry" | "exit" | "normal" | "conditional" | "loop";
+    start_line: number;
+    end_line: number;
+}
+export interface CFGEdge {
+    from: number;
+    to: number;
+    type: "sequential" | "true" | "false" | "exception" | "back" | "break" | "continue";
+}
+export interface DFG {
+    defs: DFGDef[];
+    uses: DFGUse[];
+    chains?: DFGChain[];
+}
+export interface DFGDef {
+    id: number;
+    variable: string;
+    line: number;
+    column?: number;
+    kind: "param" | "local" | "field" | "return";
+    expression?: string;
+}
+export interface DFGUse {
+    id: number;
+    variable: string;
+    line: number;
+    column?: number;
+    def_id: number | null;
+}
+export interface DFGChain {
+    from_def: number;
+    to_def: number;
+    via: string;
+}
+export interface Taint {
+    sources: TaintSource[];
+    sinks: TaintSink[];
+    sanitizers?: TaintSanitizer[];
+    flows?: TaintFlowInfo[];
+    interprocedural?: InterproceduralInfo;
+}
+export interface InterproceduralInfo {
+    tainted_methods: string[];
+    taint_bridges: string[];
+    method_flows: MethodTaintFlow[];
+}
+export interface MethodTaintFlow {
+    caller: string;
+    callee: string;
+    call_line: number;
+    tainted_args: number[];
+    returns_taint: boolean;
+}
+export interface TaintFlowInfo {
+    source_line: number;
+    sink_line: number;
+    source_type: SourceType;
+    sink_type: SinkType;
+    path: TaintFlowStep[];
+    confidence: number;
+    sanitized: boolean;
+}
+export interface TaintFlowStep {
+    variable: string;
+    line: number;
+    type: 'source' | 'assignment' | 'use' | 'return' | 'field' | 'sink';
+}
+export type SourceType = "http_param" | "http_body" | "http_header" | "http_cookie" | "http_path" | "http_query" | "io_input" | "env_input" | "db_input" | "network_input" | "file_input" | "config_param" | "interprocedural_param" | "plugin_param" | "constructor_field";
+export type SinkType = "sql_injection" | "nosql_injection" | "command_injection" | "path_traversal" | "xss" | "xxe" | "deserialization" | "ldap_injection" | "xpath_injection" | "ssrf" | "open_redirect" | "code_injection" | "log_injection" | "weak_random" | "weak_hash" | "weak_crypto" | "insecure_cookie" | "trust_boundary" | "external_taint_escape";
+export type Severity = "critical" | "high" | "medium" | "low";
+export interface TaintSource {
+    type: SourceType;
+    location: string;
+    severity: Severity;
+    line: number;
+    confidence: number;
+    variable?: string;
+    method?: string;
+    annotation?: string;
+}
+export interface TaintSink {
+    type: SinkType;
+    cwe: string;
+    location: string;
+    line: number;
+    confidence: number;
+    method?: string;
+    argPositions?: number[];
+}
+export interface TaintSanitizer {
+    type: string;
+    method: string;
+    line: number;
+    sanitizes: SinkType[];
+}
+export interface ImportInfo {
+    imported_name: string;
+    from_package: string | null;
+    alias: string | null;
+    is_wildcard: boolean;
+    line_number: number | null;
+}
+export interface ExportInfo {
+    symbol: string;
+    kind: "class" | "interface" | "method" | "field";
+    visibility: "public" | "protected" | "package";
+}
+export interface UnresolvedItem {
+    type: "virtual_dispatch" | "taint_propagation" | "reflection" | "dynamic_call";
+    call_id?: number;
+    reason: string;
+    context: {
+        code: string;
+        line: number;
+        candidates?: string[];
+    };
+    llm_question: string;
+}
+export interface Enriched {
+    functions?: EnrichedFunction[];
+    additional_sources?: TaintSource[];
+    additional_sinks?: TaintSink[];
+    resolved_calls?: ResolvedCall[];
+    llmVerification?: LLMVerificationResult;
+}
+export interface LLMVerificationResult {
+    verified: LLMVerifiedVulnerability[];
+    stats?: {
+        enrichmentTimeMs?: number;
+        verificationTimeMs?: number;
+        totalTimeMs?: number;
+        sourcesFound?: number;
+        sinksFound?: number;
+        vulnerabilitiesVerified?: number;
+    };
+}
+export interface LLMVerifiedVulnerability {
+    sourceFile: string;
+    sourceLine: number;
+    sinkLine: number;
+    cwe: string;
+    type: string;
+    verdict: 'TRUE_POSITIVE' | 'FALSE_POSITIVE' | 'UNCERTAIN';
+    confidence: number;
+    reasoning: string;
+    exploitability: 'high' | 'medium' | 'low' | 'none';
+    attackVector?: string;
+    prerequisites?: string[];
+}
+export interface EnrichedFunction {
+    method_name: string;
+    role: "controller" | "service" | "repository" | "utility";
+    risk: Severity;
+    trust_boundary: "entry_point" | "internal" | "external";
+    summary: string;
+}
+export interface ResolvedCall {
+    call_id: number;
+    resolved_to: string;
+    confidence: number;
+    reason: string;
+}
+export interface Finding {
+    id: string;
+    type: SinkType;
+    cwe: string;
+    severity: Severity;
+    confidence: number;
+    source: {
+        file: string;
+        line: number;
+        code: string;
+    };
+    sink: {
+        file: string;
+        line: number;
+        code: string;
+    };
+    path?: TaintHop[];
+    exploitable: boolean;
+    explanation: string;
+    remediation: string;
+    verification: {
+        graph_path_exists: boolean;
+        llm_verified: boolean;
+        llm_confidence: number;
+    };
+}
+export interface TaintHop {
+    file: string;
+    method: string;
+    line: number;
+    code: string;
+    variable: string;
+}
+export interface ProjectMeta {
+    name: string;
+    root: string;
+    language: SupportedLanguage;
+    framework?: string;
+    framework_version?: string;
+    build_tool?: "maven" | "gradle" | "ant" | "unknown";
+    total_files: number;
+    total_loc: number;
+    analyzed_at: string;
+}
+export interface CrossFileCall {
+    id: string;
+    from: {
+        file: string;
+        method: string;
+        line: number;
+    };
+    to: {
+        file: string;
+        method: string;
+        line: number;
+    };
+    args_mapping: ArgMapping[];
+    resolved: boolean;
+}
+export interface ArgMapping {
+    caller_arg: number;
+    callee_param: number;
+    taint_propagates: boolean;
+}
+export interface TypeHierarchy {
+    classes: Record<string, ClassHierarchyInfo>;
+    interfaces: Record<string, InterfaceHierarchyInfo>;
+}
+export interface ClassHierarchyInfo {
+    file: string;
+    extends: string | null;
+    implements: string[];
+    subclasses: string[];
+}
+export interface InterfaceHierarchyInfo {
+    file: string;
+    extends: string[];
+    implementations: string[];
+}
+export interface TaintPath {
+    id: string;
+    source: {
+        file: string;
+        line: number;
+        type: SourceType;
+        code: string;
+    };
+    sink: {
+        file: string;
+        line: number;
+        type: SinkType;
+        cwe: string;
+        code: string;
+    };
+    hops: TaintHop[];
+    sanitizers_in_path: string[];
+    path_exists: boolean;
+    confidence: number;
+}
+export interface ProjectAnalysis {
+    meta: ProjectMeta;
+    files: FileAnalysis[];
+    type_hierarchy: TypeHierarchy;
+    cross_file_calls: CrossFileCall[];
+    taint_paths: TaintPath[];
+    findings: Finding[];
+}
+export interface FileAnalysis {
+    file: string;
+    analysis: CircleIR;
+}
+export interface CircleIR {
+    meta: Meta;
+    types: TypeInfo[];
+    calls: CallInfo[];
+    cfg: CFG;
+    dfg: DFG;
+    taint: Taint;
+    imports: ImportInfo[];
+    exports: ExportInfo[];
+    unresolved: UnresolvedItem[];
+    enriched: Enriched;
+}
+export interface AnalysisResponse {
+    success: boolean;
+    analysis: {
+        sources: TaintSource[];
+        sinks: TaintSink[];
+        vulnerabilities: Vulnerability[];
+    };
+    meta: {
+        parseTimeMs: number;
+        analysisTimeMs: number;
+        totalTimeMs: number;
+    };
+}
+export interface Vulnerability {
+    type: SinkType;
+    cwe: string;
+    severity: Severity;
+    source: {
+        line: number;
+        type: SourceType;
+    };
+    sink: {
+        line: number;
+        type: SinkType;
+    };
+    confidence: number;
+    path?: string[];
+}

package/dist/types/index.js

@@ -0,0 +1,7 @@
+/**
+ * Circle-IR 3.0 TypeScript Type Definitions
+ *
+ * These types conform to docs/SPEC.md
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Centralized logging module using pino.
+ *
+ * Usage:
+ *   import { logger } from './utils/logger.js';
+ *   logger.info('Processing file', { file: 'test.java' });
+ *   logger.error('Failed to parse', { error: err.message });
+ *
+ * Log Levels (in order of severity):
+ *   - trace: Very detailed debugging
+ *   - debug: Debugging information
+ *   - info: General information (default for CLI)
+ *   - warn: Warnings
+ *   - error: Errors
+ *   - fatal: Fatal errors
+ *   - silent: No logging
+ *
+ * Configuration:
+ *   - Set LOG_LEVEL env var to change level
+ *   - Set LOG_FORMAT=json for JSON output (default in non-TTY)
+ *   - Set LOG_FORMAT=pretty for human-readable output
+ */
+import pino, { Logger } from 'pino';
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'silent';
+export interface LoggerConfig {
+    level?: LogLevel;
+    pretty?: boolean;
+    name?: string;
+}
+/**
+ * Configure the logger. Should be called early in application startup.
+ * Subsequent calls will reconfigure the logger.
+ */
+export declare function configureLogger(config: Partial<LoggerConfig>): void;
+/**
+ * Set the log level dynamically
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * Get the current log level
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * Create a child logger with additional context
+ */
+export declare function createChildLogger(bindings: Record<string, unknown>): Logger;
+/**
+ * The main logger instance.
+ * Use this for all logging throughout the application.
+ */
+export declare const logger: {
+    /**
+     * Log at trace level (most verbose)
+     */
+    trace: (msg: string, obj?: Record<string, unknown>) => void;
+    /**
+     * Log at debug level
+     */
+    debug: (msg: string, obj?: Record<string, unknown>) => void;
+    /**
+     * Log at info level (default)
+     */
+    info: (msg: string, obj?: Record<string, unknown>) => void;
+    /**
+     * Log at warn level
+     */
+    warn: (msg: string, obj?: Record<string, unknown>) => void;
+    /**
+     * Log at error level
+     */
+    error: (msg: string, obj?: Record<string, unknown>) => void;
+    /**
+     * Log at fatal level (most severe)
+     */
+    fatal: (msg: string, obj?: Record<string, unknown>) => void;
+    /**
+     * Create a child logger with additional context
+     */
+    child: (bindings: Record<string, unknown>) => pino.Logger;
+    /**
+     * Check if a level is enabled
+     */
+    isLevelEnabled: (level: LogLevel) => boolean;
+};
+export type { Logger } from 'pino';

package/dist/utils/logger.js

@@ -0,0 +1,198 @@
+/**
+ * Centralized logging module using pino.
+ *
+ * Usage:
+ *   import { logger } from './utils/logger.js';
+ *   logger.info('Processing file', { file: 'test.java' });
+ *   logger.error('Failed to parse', { error: err.message });
+ *
+ * Log Levels (in order of severity):
+ *   - trace: Very detailed debugging
+ *   - debug: Debugging information
+ *   - info: General information (default for CLI)
+ *   - warn: Warnings
+ *   - error: Errors
+ *   - fatal: Fatal errors
+ *   - silent: No logging
+ *
+ * Configuration:
+ *   - Set LOG_LEVEL env var to change level
+ *   - Set LOG_FORMAT=json for JSON output (default in non-TTY)
+ *   - Set LOG_FORMAT=pretty for human-readable output
+ */
+import pino from 'pino';
+// Default configuration
+const DEFAULT_CONFIG = {
+    level: process.env.LOG_LEVEL || 'info',
+    pretty: process.env.LOG_FORMAT === 'pretty' || (process.stdout.isTTY && process.env.LOG_FORMAT !== 'json'),
+    name: 'circle-ir',
+};
+let currentConfig = { ...DEFAULT_CONFIG };
+let loggerInstance = null;
+/**
+ * Create pino logger options from config
+ */
+function createLoggerOptions(config) {
+    const options = {
+        name: config.name,
+        level: config.level || 'info',
+    };
+    // Add pretty printing for TTY or when explicitly requested
+    if (config.pretty) {
+        options.transport = {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname',
+                messageFormat: '{msg}',
+                singleLine: true,
+            },
+        };
+    }
+    return options;
+}
+/**
+ * Get the singleton logger instance
+ */
+function getLogger() {
+    if (!loggerInstance) {
+        const options = createLoggerOptions(currentConfig);
+        // Write to stderr to avoid polluting stdout for CLI tools
+        if (options.transport) {
+            // When using transport (pino-pretty), specify destination in options
+            options.transport.options = {
+                ...options.transport.options,
+                destination: 2, // stderr file descriptor
+            };
+            loggerInstance = pino(options);
+        }
+        else {
+            loggerInstance = pino(options, process.stderr);
+        }
+    }
+    return loggerInstance;
+}
+/**
+ * Configure the logger. Should be called early in application startup.
+ * Subsequent calls will reconfigure the logger.
+ */
+export function configureLogger(config) {
+    currentConfig = { ...currentConfig, ...config };
+    const options = createLoggerOptions(currentConfig);
+    // Write to stderr to avoid polluting stdout for CLI tools
+    if (options.transport) {
+        options.transport.options = {
+            ...options.transport.options,
+            destination: 2, // stderr file descriptor
+        };
+        loggerInstance = pino(options);
+    }
+    else {
+        loggerInstance = pino(options, process.stderr);
+    }
+}
+/**
+ * Set the log level dynamically
+ */
+export function setLogLevel(level) {
+    currentConfig.level = level;
+    if (loggerInstance) {
+        loggerInstance.level = level;
+    }
+}
+/**
+ * Get the current log level
+ */
+export function getLogLevel() {
+    return currentConfig.level || 'info';
+}
+/**
+ * Create a child logger with additional context
+ */
+export function createChildLogger(bindings) {
+    return getLogger().child(bindings);
+}
+/**
+ * The main logger instance.
+ * Use this for all logging throughout the application.
+ */
+export const logger = {
+    /**
+     * Log at trace level (most verbose)
+     */
+    trace: (msg, obj) => {
+        if (obj) {
+            getLogger().trace(obj, msg);
+        }
+        else {
+            getLogger().trace(msg);
+        }
+    },
+    /**
+     * Log at debug level
+     */
+    debug: (msg, obj) => {
+        if (obj) {
+            getLogger().debug(obj, msg);
+        }
+        else {
+            getLogger().debug(msg);
+        }
+    },
+    /**
+     * Log at info level (default)
+     */
+    info: (msg, obj) => {
+        if (obj) {
+            getLogger().info(obj, msg);
+        }
+        else {
+            getLogger().info(msg);
+        }
+    },
+    /**
+     * Log at warn level
+     */
+    warn: (msg, obj) => {
+        if (obj) {
+            getLogger().warn(obj, msg);
+        }
+        else {
+            getLogger().warn(msg);
+        }
+    },
+    /**
+     * Log at error level
+     */
+    error: (msg, obj) => {
+        if (obj) {
+            getLogger().error(obj, msg);
+        }
+        else {
+            getLogger().error(msg);
+        }
+    },
+    /**
+     * Log at fatal level (most severe)
+     */
+    fatal: (msg, obj) => {
+        if (obj) {
+            getLogger().fatal(obj, msg);
+        }
+        else {
+            getLogger().fatal(msg);
+        }
+    },
+    /**
+     * Create a child logger with additional context
+     */
+    child: (bindings) => createChildLogger(bindings),
+    /**
+     * Check if a level is enabled
+     */
+    isLevelEnabled: (level) => {
+        return getLogger().isLevelEnabled(level);
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"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"}