Repository Public
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