SPB Git

Repository Public

VQSyncKinds.swift 28.5 KB 505 lines swift

1// Author: Simon-Pierre Boucher — contact@spboucher.ai2// File: Sources/VQuantKit/Sync/VQSyncKinds.swift3// Description: Typed `data` of every object kind of CONTRACT §1.1. All are views over their JSON (see VQJSONBacked):4//              unknown keys are preserved at every level.5import Foundation67// MARK: watchlist — { name*, symbols*: string[] (≤ 200), note }89public struct VQWatchlist: VQSyncData {10    public static let kind = VQObjectKind.watchlist11    public static let maxSymbols = 20012    public var raw: VQJSONObject13    public init(raw: VQJSONObject) { self.raw = raw }14    public init(name: String, symbols: [String] = [], note: String? = nil) {15        raw = [:]; self.name = name; self.symbols = symbols; self.note = note16    }17    public var name: String { get { string("name") ?? "" } set { set("name", newValue) } }18    public var symbols: [String] { get { strings("symbols") } set { set("symbols", newValue) } }19    public var note: String? { get { string("note") } set { set("note", newValue) } }2021    /// Adds a symbol (upper-cased) unless present. Returns false when it was there or the list is full.22    @discardableResult23    public mutating func add(_ symbol: String) -> Bool {24        let s = symbol.trimmingCharacters(in: .whitespaces).uppercased()25        var list = symbols26        guard !s.isEmpty, !list.contains(s), list.count < Self.maxSymbols else { return false }27        list.append(s); symbols = list28        return true29    }30    public mutating func remove(_ symbol: String) { symbols = symbols.filter { $0 != symbol } }3132    public func validationIssues() -> [String] {33        var out: [String] = []34        if raw["name"]?.stringValue == nil { out.append("name") }35        if raw["symbols"]?.arrayValue == nil { out.append("symbols") }36        if symbols.count > Self.maxSymbols { out.append("symbols (≤ \(Self.maxSymbols))") }37        return out38    }39}4041// MARK: portfolio — { name*, baseCurrency*, benchmark, cash: [{ currency, amount }], positions*: [...] }4243public struct VQPortfolio: VQSyncData {44    public static let kind = VQObjectKind.portfolio45    public var raw: VQJSONObject46    public init(raw: VQJSONObject) { self.raw = raw }47    public init(name: String, baseCurrency: String = "USD", benchmark: String? = nil, cash: [Cash] = [], positions: [Position] = []) {48        raw = [:]; self.name = name; self.baseCurrency = baseCurrency; self.benchmark = benchmark49        if !cash.isEmpty { self.cash = cash }50        self.positions = positions51    }52    public var name: String { get { string("name") ?? "" } set { set("name", newValue) } }53    public var baseCurrency: String { get { string("baseCurrency") ?? "USD" } set { set("baseCurrency", newValue) } }54    /// Default "SPY" when absent.55    public var benchmark: String? { get { string("benchmark") } set { set("benchmark", newValue) } }56    public var cash: [Cash] { get { items("cash") } set { set("cash", items: newValue) } }57    public var positions: [Position] { get { items("positions") } set { set("positions", items: newValue) } }5859    public struct Cash: VQJSONBacked {60        public var raw: VQJSONObject61        public init(raw: VQJSONObject) { self.raw = raw }62        public init(currency: String, amount: Double) { raw = [:]; self.currency = currency; self.amount = amount }63        public var currency: String { get { string("currency") ?? "" } set { set("currency", newValue) } }64        public var amount: Double { get { double("amount") ?? 0 } set { set("amount", newValue) } }65    }6667    /// `{ symbol*, quantity*, costBasis, currency, note, openedAt }` — plus whatever other writers add68    /// (the legacy routes keep a per-position `updatedAt`, which is preserved).69    public struct Position: VQJSONBacked, Identifiable {70        public var raw: VQJSONObject71        public init(raw: VQJSONObject) { self.raw = raw }72        public init(symbol: String, quantity: Double, costBasis: Double? = nil, currency: String? = nil, note: String? = nil, openedAt: Date? = nil) {73            raw = [:]; self.symbol = symbol; self.quantity = quantity; self.costBasis = costBasis; self.currency = currency; self.note = note; self.openedAt = openedAt74        }75        public var id: String { symbol }76        public var symbol: String { get { string("symbol") ?? "" } set { set("symbol", newValue) } }77        public var quantity: Double { get { double("quantity") ?? 0 } set { set("quantity", newValue) } }78        public var costBasis: Double? { get { double("costBasis") } set { set("costBasis", newValue) } }79        public var currency: String? { get { string("currency") } set { set("currency", newValue) } }80        public var note: String? { get { string("note") } set { set("note", newValue) } }81        public var openedAt: Date? { get { date("openedAt") } set { set("openedAt", date: newValue) } }82    }8384    public func position(_ symbol: String) -> Position? { positions.first { $0.symbol == symbol } }85    /// Inserts or replaces the position of that symbol (keys the caller did not set on an existing position are kept).86    public mutating func upsert(_ position: Position) {87        var list = positions88        if let i = list.firstIndex(where: { $0.symbol == position.symbol }) {89            var merged = list[i].raw90            for (k, v) in position.raw { merged[k] = v }91            list[i] = Position(raw: merged)92        } else { list.append(position) }93        positions = list94    }95    public mutating func removePosition(_ symbol: String) { positions = positions.filter { $0.symbol != symbol } }9697    public func validationIssues() -> [String] {98        var out: [String] = []99        if raw["name"]?.stringValue == nil { out.append("name") }100        if raw["baseCurrency"]?.stringValue == nil { out.append("baseCurrency") }101        if raw["positions"]?.arrayValue == nil { out.append("positions") }102        for (i, p) in positions.enumerated() {103            if p.raw["symbol"]?.stringValue == nil { out.append("positions[\(i)].symbol") }104            if p.raw["quantity"]?.doubleValue == nil { out.append("positions[\(i)].quantity") }105        }106        return out107    }108}109110// MARK: workspace — { name*, icon, layout*: LayoutNode, panels*: { [panelId]: Panel } }111112public struct VQWorkspace: VQSyncData {113    public static let kind = VQObjectKind.workspace114    public var raw: VQJSONObject115    public init(raw: VQJSONObject) { self.raw = raw }116    public init(name: String, icon: String? = nil, layout: VQLayoutNode, panels: [String: VQPanel]) {117        raw = [:]; self.name = name; self.icon = icon; self.layout = layout; self.panels = panels118    }119    public var name: String { get { string("name") ?? "" } set { set("name", newValue) } }120    public var icon: String? { get { string("icon") } set { set("icon", newValue) } }121    public var layout: VQLayoutNode { get { item("layout") ?? VQLayoutNode(raw: [:]) } set { set("layout", item: newValue) } }122    public var panels: [String: VQPanel] {123        get { (raw["panels"]?.objectValue ?? [:]).compactMapValues { $0.objectValue.map(VQPanel.init(raw:)) } }124        set { raw["panels"] = .object(newValue.mapValues(\.json)) }125    }126127    /// Adds a panel and splits the given leaf (or the root) to show it.128    public mutating func addPanel(_ panel: VQPanel, id: String = VQObjectID.make(), beside target: String? = nil, direction: VQLayoutNode.Direction = .row) {129        var p = panels; p[id] = panel; panels = p130        let leaf = VQLayoutNode.panel(id)131        if layout.kind == nil { layout = leaf; return }132        layout = layout.splitting(target ?? layout.panelIds.last ?? "", with: leaf, direction: direction) ?? .split(direction, children: [layout, leaf])133    }134    /// Removes a panel and its leaf; a split left with one child collapses into that child.135    public mutating func removePanel(_ id: String) {136        var p = panels; p[id] = nil; panels = p137        layout = layout.removing(panelId: id) ?? VQLayoutNode(raw: [:])138    }139140    public func validationIssues() -> [String] {141        var out: [String] = []142        if raw["name"]?.stringValue == nil { out.append("name") }143        if raw["layout"]?.objectValue == nil { out.append("layout") } else { out += layout.validationIssues(path: "layout") }144        if raw["panels"]?.objectValue == nil { out.append("panels") }145        let known = Set(panels.keys)146        for id in layout.panelIds where !known.contains(id) { out.append("layout: panel \(id) is not in panels") }147        return out148    }149}150151/// `{ type: "split", direction, sizes, children } | { type: "panel", panelId }` — a recursive view over its JSON.152public struct VQLayoutNode: VQJSONBacked {153    public enum Kind: String, Sendable, Hashable, CaseIterable { case split, panel }154    public enum Direction: String, Sendable, Hashable, CaseIterable { case row, column }155156    public var raw: VQJSONObject157    public init(raw: VQJSONObject) { self.raw = raw }158159    public static func panel(_ panelId: String) -> VQLayoutNode { VQLayoutNode(raw: ["type": "panel", "panelId": .string(panelId)]) }160    /// `sizes` default to equal shares.161    public static func split(_ direction: Direction, sizes: [Double]? = nil, children: [VQLayoutNode]) -> VQLayoutNode {162        let n = max(1, children.count)163        return VQLayoutNode(raw: ["type": "split", "direction": .string(direction.rawValue),164                                  "sizes": VQJSON(sizes ?? Array(repeating: 1 / Double(n), count: children.count)),165                                  "children": .array(children.map(\.json))])166    }167168    /// nil for a node type this version does not know (it is kept as it is).169    public var kind: Kind? { string("type").flatMap(Kind.init(rawValue:)) }170    public var direction: Direction? { get { string("direction").flatMap(Direction.init(rawValue:)) } set { set("direction", newValue?.rawValue) } }171    public var sizes: [Double] { get { doubles("sizes") } set { set("sizes", newValue) } }172    public var children: [VQLayoutNode] { get { items("children") } set { set("children", items: newValue) } }173    public var panelId: String? { get { string("panelId") } set { set("panelId", newValue) } }174175    /// Sizes normalised to sum to 1, one per child (equal shares when the stored sizes do not match the children).176    public var fractions: [Double] {177        let n = children.count178        let s = sizes179        let total = s.reduce(0, +)180        guard n > 0 else { return [] }181        guard s.count == n, total > 0, s.allSatisfy({ $0 > 0 }) else { return Array(repeating: 1 / Double(n), count: n) }182        return s.map { $0 / total }183    }184185    /// Panel ids of the leaves, in reading order.186    public var panelIds: [String] {187        switch kind {188        case .panel: return panelId.map { [$0] } ?? []189        case .split: return children.flatMap(\.panelIds)190        case nil: return []191        }192    }193194    public func removing(panelId id: String) -> VQLayoutNode? {195        switch kind {196        case .panel: return panelId == id ? nil : self197        case .split:198            let old = children199            let fr = fractions200            var keptChildren: [VQLayoutNode] = [], keptSizes: [Double] = []201            for (i, c) in old.enumerated() {202                if let k = c.removing(panelId: id) { keptChildren.append(k); keptSizes.append(fr[i]) }203            }204            if keptChildren.isEmpty { return nil }205            if keptChildren.count == 1 { return keptChildren[0] }206            var copy = self207            copy.children = keptChildren208            let total = keptSizes.reduce(0, +)209            copy.sizes = keptSizes.map { total > 0 ? $0 / total : 1 / Double(keptSizes.count) }210            return copy211        case nil: return self212        }213    }214215    /// Replaces the leaf `target` by a split holding it and `node`. nil when the leaf is not in this tree.216    public func splitting(_ target: String, with node: VQLayoutNode, direction: Direction) -> VQLayoutNode? {217        switch kind {218        case .panel: return panelId == target ? .split(direction, children: [self, node]) : nil219        case .split:220            var list = children221            for i in list.indices {222                if let replaced = list[i].splitting(target, with: node, direction: direction) {223                    list[i] = replaced224                    var copy = self; copy.children = list225                    return copy226                }227            }228            return nil229        case nil: return nil230        }231    }232233    func validationIssues(path: String) -> [String] {234        switch kind {235        case .panel: return panelId == nil ? ["\(path).panelId"] : []236        case .split:237            var out: [String] = []238            if direction == nil { out.append("\(path).direction") }239            if children.isEmpty { out.append("\(path).children") }240            if sizes.count != children.count { out.append("\(path).sizes") }241            for (i, c) in children.enumerated() { out += c.validationIssues(path: "\(path).children[\(i)]") }242            return out243        case nil: return ["\(path).type"]244        }245    }246}247248/// `{ type, title, config }`249public struct VQPanel: VQJSONBacked {250    public enum PanelType: String, Sendable, Hashable, CaseIterable {251        case chart, watchlist, quote, statements, news, chat, notebook, quant, portfolio, options, macro, risk, note, table252    }253    public var raw: VQJSONObject254    public init(raw: VQJSONObject) { self.raw = raw }255    public init(type: PanelType, title: String? = nil, config: VQJSONObject = [:]) {256        raw = [:]; self.type = .known(type); self.title = title; self.config = config257    }258    /// A panel type added later decodes as `.unknown` (show a placeholder, keep the panel).259    public var type: VQOpen<PanelType> { get { VQOpen(string("type") ?? "") } set { set("type", newValue.rawValue) } }260    public var title: String? { get { string("title") } set { set("title", newValue) } }261    public var config: VQJSONObject { get { raw["config"]?.objectValue ?? [:] } set { raw["config"] = .object(newValue) } }262}263264// MARK: chart265266public struct VQChart: VQSyncData {267    public static let kind = VQObjectKind.chart268    public enum ChartType: String, Sendable, Hashable, CaseIterable { case candles, ohlc, line, area }269    public var raw: VQJSONObject270    public init(raw: VQJSONObject) { self.raw = raw }271    public init(symbol: String, interval: String = "1d", chartType: ChartType = .candles) {272        raw = [:]; self.symbol = symbol; self.interval = interval; self.chartType = .known(chartType)273    }274    public var symbol: String { get { string("symbol") ?? "" } set { set("symbol", newValue) } }275    /// Default "1d".276    public var interval: String { get { string("interval") ?? "1d" } set { set("interval", newValue) } }277    public var range: String? { get { string("range") } set { set("range", newValue) } }278    public var chartType: VQOpen<ChartType> { get { VQOpen(string("chartType") ?? "candles") } set { set("chartType", newValue.rawValue) } }279    public var logScale: Bool { get { bool("logScale") ?? false } set { set("logScale", newValue) } }280    /// `split_div` | `split` | `none`281    public var adjust: String? { get { string("adjust") } set { set("adjust", newValue) } }282    public var indicators: [Indicator] { get { items("indicators") } set { set("indicators", items: newValue) } }283    public var compare: [String] { get { strings("compare") } set { set("compare", newValue) } }284    public var drawings: [Drawing] { get { items("drawings") } set { set("drawings", items: newValue) } }285    public var events: Bool { get { bool("events") ?? false } set { set("events", newValue) } }286287    public struct Indicator: VQJSONBacked, Identifiable {288        public var raw: VQJSONObject289        public init(raw: VQJSONObject) { self.raw = raw }290        public init(id: String = VQObjectID.make(), type: String, params: VQJSONObject = [:], pane: String? = nil) {291            raw = [:]; self.id = id; self.type = type; self.params = params; self.pane = pane292        }293        public var id: String { get { string("id") ?? "" } set { set("id", newValue) } }294        public var type: String { get { string("type") ?? "" } set { set("type", newValue) } }295        public var params: VQJSONObject { get { raw["params"]?.objectValue ?? [:] } set { raw["params"] = .object(newValue) } }296        public var pane: String? { get { string("pane") } set { set("pane", newValue) } }297    }298299    /// `{ id, type, points: [{ t, p }], style, text }` — `t` = epoch seconds of the bar, `p` = price.300    public struct Drawing: VQJSONBacked, Identifiable {301        public var raw: VQJSONObject302        public init(raw: VQJSONObject) { self.raw = raw }303        public init(id: String = VQObjectID.make(), type: String, points: [Point], style: VQJSONObject? = nil, text: String? = nil) {304            raw = [:]; self.id = id; self.type = type; self.points = points305            if let style { self.style = style }306            self.text = text307        }308        public var id: String { get { string("id") ?? "" } set { set("id", newValue) } }309        public var type: String { get { string("type") ?? "" } set { set("type", newValue) } }310        public var points: [Point] { get { items("points") } set { set("points", items: newValue) } }311        public var style: VQJSONObject { get { raw["style"]?.objectValue ?? [:] } set { raw["style"] = .object(newValue) } }312        public var text: String? { get { string("text") } set { set("text", newValue) } }313314        public struct Point: VQJSONBacked {315            public var raw: VQJSONObject316            public init(raw: VQJSONObject) { self.raw = raw }317            public init(t: Double, p: Double) { raw = ["t": .number(t), "p": .number(p)] }318            public var t: Double { get { double("t") ?? 0 } set { set("t", newValue) } }319            public var p: Double { get { double("p") ?? 0 } set { set("p", newValue) } }320            public var date: Date { Date(timeIntervalSince1970: t) }321        }322    }323324    public func validationIssues() -> [String] { raw["symbol"]?.stringValue == nil ? ["symbol"] : [] }325}326327// MARK: project328329public struct VQProject: VQSyncData {330    public static let kind = VQObjectKind.project331    public enum Status: String, Sendable, Hashable, CaseIterable { case active, paused, done, archived }332    public var raw: VQJSONObject333    public init(raw: VQJSONObject) { self.raw = raw }334    public init(title: String, question: String? = nil, items: [Item] = []) {335        raw = [:]; self.title = title; self.question = question; self.items = items336    }337    public var title: String { get { string("title") ?? "" } set { set("title", newValue) } }338    public var question: String? { get { string("question") } set { set("question", newValue) } }339    public var hypotheses: [Hypothesis] { get { items("hypotheses") } set { set("hypotheses", items: newValue) } }340    public var status: VQOpen<Status>? { get { string("status").map(VQOpen.init) } set { set("status", newValue?.rawValue) } }341    public var dataSources: [DataSource] { get { items("dataSources") } set { set("dataSources", items: newValue) } }342    public var items: [Item] { get { items("items") } set { set("items", items: newValue) } }343    public var summary: String? { get { string("summary") } set { set("summary", newValue) } }344345    public struct Hypothesis: VQJSONBacked, Identifiable {346        public enum Status: String, Sendable, Hashable, CaseIterable { case open, supported, rejected, inconclusive }347        public var raw: VQJSONObject348        public init(raw: VQJSONObject) { self.raw = raw }349        public init(id: String = VQObjectID.make(), text: String, status: Status = .open) {350            raw = [:]; self.id = id; self.text = text; self.status = .known(status)351        }352        public var id: String { get { string("id") ?? "" } set { set("id", newValue) } }353        public var text: String { get { string("text") ?? "" } set { set("text", newValue) } }354        public var status: VQOpen<Status> { get { VQOpen(string("status") ?? "open") } set { set("status", newValue.rawValue) } }355    }356357    public struct DataSource: VQJSONBacked, Identifiable {358        public var raw: VQJSONObject359        public init(raw: VQJSONObject) { self.raw = raw }360        public init(id: String = VQObjectID.make(), provider: String, description: String? = nil) {361            raw = [:]; self.id = id; self.provider = provider; self.description = description362        }363        public var id: String { get { string("id") ?? "" } set { set("id", newValue) } }364        public var provider: String { get { string("provider") ?? "" } set { set("provider", newValue) } }365        public var description: String? { get { string("description") } set { set("description", newValue) } }366    }367368    /// `{ id, type, ref*, title, addedAt }` — `ref` by type: session id, job id, object id, share id (CONTRACT §5.1).369    public struct Item: VQJSONBacked, Identifiable {370        public enum ItemType: String, Sendable, Hashable, CaseIterable {371            case conversation, quantJob = "quant_job", note, chart, report, notebook, dataset, review, portfolio, watchlist372        }373        public var raw: VQJSONObject374        public init(raw: VQJSONObject) { self.raw = raw }375        public init(id: String = VQObjectID.make(), type: ItemType, ref: String, title: String? = nil, addedAt: Date? = nil) {376            raw = [:]; self.id = id; self.type = .known(type); self.ref = ref; self.title = title; self.addedAt = addedAt377        }378        public var id: String { get { string("id") ?? "" } set { set("id", newValue) } }379        public var type: VQOpen<ItemType> { get { VQOpen(string("type") ?? "") } set { set("type", newValue.rawValue) } }380        public var ref: String { get { string("ref") ?? "" } set { set("ref", newValue) } }381        public var title: String? { get { string("title") } set { set("title", newValue) } }382        public var addedAt: Date? { get { date("addedAt") } set { set("addedAt", date: newValue) } }383    }384385    public func validationIssues() -> [String] {386        var out: [String] = []387        if raw["title"]?.stringValue == nil { out.append("title") }388        if raw["items"]?.arrayValue == nil { out.append("items") }389        for (i, it) in items.enumerated() where it.raw["ref"]?.stringValue == nil { out.append("items[\(i)].ref") }390        return out391    }392}393394// MARK: note — { title*, body* (markdown), projectId }395396public struct VQNote: VQSyncData {397    public static let kind = VQObjectKind.note398    public var raw: VQJSONObject399    public init(raw: VQJSONObject) { self.raw = raw }400    public init(title: String, body: String, projectId: String? = nil) {401        raw = [:]; self.title = title; self.body = body; self.projectId = projectId402    }403    public var title: String { get { string("title") ?? "" } set { set("title", newValue) } }404    public var body: String { get { string("body") ?? "" } set { set("body", newValue) } }405    public var projectId: String? { get { string("projectId") } set { set("projectId", newValue) } }406    public func validationIssues() -> [String] {407        (raw["title"]?.stringValue == nil ? ["title"] : []) + (raw["body"]?.stringValue == nil ? ["body"] : [])408    }409}410411// MARK: preference — single object, id `default`412413public struct VQPreference: VQSyncData {414    public static let kind = VQObjectKind.preference415    public enum UpDownColors: String, Sendable, Hashable, CaseIterable { case classic, cvd }416    public enum RoutingStrategy: String, Sendable, Hashable, CaseIterable { case quality, balanced, economy }417418    public var raw: VQJSONObject419    public init(raw: VQJSONObject) { self.raw = raw }420    public init() { raw = [:] }421422    public var theme: String? { get { string("theme") } set { set("theme", newValue) } }423    public var accent: String? { get { string("accent") } set { set("accent", newValue) } }424    public var density: String? { get { string("density") } set { set("density", newValue) } }425    /// "fr-CA" | "en-CA"426    public var numberFormat: String? { get { string("numberFormat") } set { set("numberFormat", newValue) } }427    public var upDownColors: VQOpen<UpDownColors>? { get { string("upDownColors").map(VQOpen.init) } set { set("upDownColors", newValue?.rawValue) } }428    public var reduceMotion: Bool? { get { bool("reduceMotion") } set { set("reduceMotion", newValue) } }429    public var defaultModel: String? { get { string("defaultModel") } set { set("defaultModel", newValue) } }430    public var defaultMode: String? { get { string("defaultMode") } set { set("defaultMode", newValue) } }431    public var routing: Routing? { get { item("routing") } set { set("routing", item: newValue) } }432    public var budget: Budget? { get { item("budget") } set { set("budget", item: newValue) } }433    public var memory: Memory? { get { item("memory") } set { set("memory", item: newValue) } }434    public var recentSearches: [String] { get { strings("recentSearches") } set { set("recentSearches", newValue) } }435    public var homeWorkspaceId: String? { get { string("homeWorkspaceId") } set { set("homeWorkspaceId", newValue) } }436437    public struct Routing: VQJSONBacked {438        public var raw: VQJSONObject439        public init(raw: VQJSONObject) { self.raw = raw }440        public init(strategy: RoutingStrategy, providers: [String]) { raw = [:]; self.strategy = .known(strategy); self.providers = providers }441        public var strategy: VQOpen<RoutingStrategy>? { get { string("strategy").map(VQOpen.init) } set { set("strategy", newValue?.rawValue) } }442        public var providers: [String] { get { strings("providers") } set { set("providers", newValue) } }443    }444    public struct Budget: VQJSONBacked {445        public var raw: VQJSONObject446        public init(raw: VQJSONObject) { self.raw = raw }447        public init(maxCostUsd: Double? = nil, maxMinutes: Double? = nil) { raw = [:]; self.maxCostUsd = maxCostUsd; self.maxMinutes = maxMinutes }448        public var maxCostUsd: Double? { get { double("maxCostUsd") } set { set("maxCostUsd", newValue) } }449        public var maxMinutes: Double? { get { double("maxMinutes") } set { set("maxMinutes", newValue) } }450    }451    public struct Memory: VQJSONBacked {452        public var raw: VQJSONObject453        public init(raw: VQJSONObject) { self.raw = raw }454        public var enabled: Bool? { get { bool("enabled") } set { set("enabled", newValue) } }455        public var retentionDays: Int? { get { int("retentionDays") } set { set("retentionDays", newValue) } }456    }457}458459// MARK: review — written by the server only (CONTRACT §5.3)460461public struct VQReview: VQSyncData {462    public static let kind = VQObjectKind.review463    public enum Status: String, Sendable, Hashable, CaseIterable { case running, done, error }464    public var raw: VQJSONObject465    public init(raw: VQJSONObject) { self.raw = raw }466467    public var target: Target? { item("target") }468    public var projectId: String? { string("projectId") }469    public var status: VQOpen<Status> { VQOpen(string("status") ?? "running") }470    /// Always true: the UI labels it "Automated review — not a human peer review".471    public var automated: Bool { bool("automated") ?? true }472    public var checks: [Check] { items("checks") }473    public var verdict: String? { string("verdict") }474    public var model: String? { string("model") }475    public var usage: VQUsage? { raw["usage"].flatMap { $0.objectValue == nil ? nil : VQUsage(json: $0) } }476    public var disclaimer: String? { string("disclaimer") }477    public var startedAt: Date? { date("startedAt") }478    public var finishedAt: Date? { date("finishedAt") }479    public var error: String? { string("error") }480481    public struct Target: VQJSONBacked {482        public enum TargetType: String, Sendable, Hashable, CaseIterable { case session, quantJob = "quant_job", note }483        public var raw: VQJSONObject484        public init(raw: VQJSONObject) { self.raw = raw }485        public init(type: TargetType, id: String) { raw = ["type": .string(type.rawValue), "id": .string(id)] }486        public var type: VQOpen<TargetType> { VQOpen(string("type") ?? "") }487        public var id: String { string("id") ?? "" }488    }489490    public struct Check: VQJSONBacked, Identifiable {491        public enum Category: String, Sendable, Hashable, CaseIterable { case math, statistics, leakage, interpretation, citations, reproducibility }492        public enum Severity: String, Sendable, Hashable, CaseIterable { case info, warning, error }493        public var raw: VQJSONObject494        public init(raw: VQJSONObject) { self.raw = raw }495        /// Deterministic checks have their own ids; the reviewer model's findings are `reviewer-n`.496        public var id: String { string("id") ?? "" }497        public var category: VQOpen<Category> { VQOpen(string("category") ?? "") }498        public var severity: VQOpen<Severity> { VQOpen(string("severity") ?? "info") }499        public var finding: String { string("finding") ?? "" }500        /// A sentence, or structured evidence rendered as compact JSON.501        public var evidence: String? { raw["evidence"].flatMap { $0.stringValue ?? ($0.isNull ? nil : $0.text()) } }502        public var isFromReviewerModel: Bool { id.hasPrefix("reviewer-") }503    }504}505
Files main
Menu

Theme