gthinking 1.2.1 → 2.1.1

package/src/types/reasoning.ts

@@ -0,0 +1,288 @@
+/**
+ * Reasoning Types for gthinking v2.0.0
+ * Types for reasoning and logical inference functionality
+ */
+
+import { z } from 'zod';
+import { BaseResultSchema } from './core';
+
+/**
+ * Reasoning Type Enum
+ */
+export enum ReasoningType {
+  DEDUCTIVE = 'deductive',
+  INDUCTIVE = 'inductive',
+  ABDUCTIVE = 'abductive',
+  ANALOGICAL = 'analogical',
+  CAUSAL = 'causal',
+  COUNTERFACTUAL = 'counterfactual',
+}
+
+/**
+ * Reasoning Type Schema
+ */
+export const ReasoningTypeSchema = z.nativeEnum(ReasoningType);
+
+/**
+ * Reasoning Request Schema
+ */
+export const ReasoningRequestSchema = z.object({
+  problem: z.string().min(1).max(10000),
+  type: ReasoningTypeSchema.default(ReasoningType.DEDUCTIVE),
+  context: z.array(z.string()).default([]),
+  constraints: z.array(z.string()).default([]),
+  options: z.object({
+    maxSteps: z.number().positive().max(20).default(5),
+    confidence: z.number().min(0).max(1).default(0.7),
+    useLLM: z.boolean().default(true),
+    includeChainOfThought: z.boolean().default(true),
+    generateHypotheses: z.boolean().default(true),
+    decomposeProblem: z.boolean().default(true),
+  }).default({}),
+});
+
+/**
+ * Reasoning Request Type
+ */
+export type ReasoningRequest = z.infer<typeof ReasoningRequestSchema>;
+
+/**
+ * Reasoning Step Schema
+ */
+export const ReasoningStepSchema = z.object({
+  id: z.string().uuid(),
+  stepNumber: z.number().positive(),
+  type: z.enum(['premise', 'observation', 'inference', 'conclusion', 'hypothesis', 'evidence']),
+  content: z.string(),
+  premise: z.string().optional(),
+  inference: z.string().optional(),
+  conclusion: z.string().optional(),
+  confidence: z.number().min(0).max(1),
+  supportingEvidence: z.array(z.string()).default([]),
+  counterEvidence: z.array(z.string()).default([]),
+  assumptions: z.array(z.string()).default([]),
+  dependencies: z.array(z.string().uuid()).default([]),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Reasoning Step Type
+ */
+export type ReasoningStep = z.infer<typeof ReasoningStepSchema>;
+
+/**
+ * Hypothesis Schema
+ */
+export const HypothesisSchema = z.object({
+  id: z.string().uuid(),
+  statement: z.string(),
+  plausibility: z.number().min(0).max(1),
+  evidence: z.array(z.object({
+    description: z.string(),
+    supports: z.boolean(),
+    strength: z.number().min(0).max(1),
+  })),
+  testable: z.boolean(),
+  tested: z.boolean().default(false),
+  testResult: z.enum(['confirmed', 'rejected', 'inconclusive']).optional(),
+});
+
+/**
+ * Hypothesis Type
+ */
+export type Hypothesis = z.infer<typeof HypothesisSchema>;
+
+/**
+ * Chain of Thought Node Schema
+ */
+export const ChainOfThoughtNodeSchema = z.object({
+  id: z.string().uuid(),
+  content: z.string(),
+  type: z.enum(['question', 'observation', 'inference', 'conclusion', 'assumption']),
+  parentId: z.string().uuid().optional(),
+  children: z.array(z.string().uuid()).default([]),
+  depth: z.number().nonnegative(),
+  confidence: z.number().min(0).max(1),
+  supportingEvidence: z.array(z.string()).default([]),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Chain of Thought Node Type
+ */
+export type ChainOfThoughtNode = z.infer<typeof ChainOfThoughtNodeSchema>;
+
+/**
+ * Chain of Thought Schema
+ */
+export const ChainOfThoughtSchema = z.object({
+  id: z.string().uuid(),
+  question: z.string(),
+  nodes: z.array(ChainOfThoughtNodeSchema),
+  rootNodeId: z.string().uuid(),
+  maxDepth: z.number().positive(),
+  finalAnswer: z.string().optional(),
+  completeness: z.number().min(0).max(1),
+  coherence: z.number().min(0).max(1),
+});
+
+/**
+ * Chain of Thought Type
+ */
+export type ChainOfThought = z.infer<typeof ChainOfThoughtSchema>;
+
+/**
+ * Logical Rule Schema
+ */
+export const LogicalRuleSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  premises: z.array(z.string()),
+  conclusion: z.string(),
+  confidence: z.number().min(0).max(1),
+  domain: z.string().optional(),
+});
+
+/**
+ * Logical Rule Type
+ */
+export type LogicalRule = z.infer<typeof LogicalRuleSchema>;
+
+/**
+ * Analogy Schema
+ */
+export const AnalogySchema = z.object({
+  id: z.string().uuid(),
+  sourceDomain: z.string(),
+  targetDomain: z.string(),
+  mapping: z.array(z.object({
+    source: z.string(),
+    target: z.string(),
+    similarity: z.number().min(0).max(1),
+  })),
+  strength: z.number().min(0).max(1),
+  explanation: z.string(),
+});
+
+/**
+ * Analogy Type
+ */
+export type Analogy = z.infer<typeof AnalogySchema>;
+
+/**
+ * Causal Chain Schema
+ */
+export const CausalChainSchema = z.object({
+  id: z.string().uuid(),
+  cause: z.string(),
+  effect: z.string(),
+  intermediates: z.array(z.object({
+    event: z.string(),
+    confidence: z.number().min(0).max(1),
+  })),
+  confidence: z.number().min(0).max(1),
+  evidence: z.array(z.string()),
+});
+
+/**
+ * Causal Chain Type
+ */
+export type CausalChain = z.infer<typeof CausalChainSchema>;
+
+/**
+ * Counterfactual Scenario Schema
+ */
+export const CounterfactualScenarioSchema = z.object({
+  id: z.string().uuid(),
+  original: z.string(),
+  alternative: z.string(),
+  changes: z.array(z.string()),
+  consequences: z.array(z.object({
+    description: z.string(),
+    probability: z.number().min(0).max(1),
+    impact: z.enum(['low', 'medium', 'high', 'critical']),
+  })),
+  plausibility: z.number().min(0).max(1),
+});
+
+/**
+ * Counterfactual Scenario Type
+ */
+export type CounterfactualScenario = z.infer<typeof CounterfactualScenarioSchema>;
+
+/**
+ * Problem Component Schema
+ */
+export const ProblemComponentSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  description: z.string(),
+  type: z.enum(['subproblem', 'constraint', 'resource', 'objective', 'stakeholder']),
+  complexity: z.number().min(0).max(1),
+  dependencies: z.array(z.string().uuid()).default([]),
+  priority: z.number().min(1).max(5),
+});
+
+/**
+ * Problem Component Type
+ */
+export type ProblemComponent = z.infer<typeof ProblemComponentSchema>;
+
+/**
+ * Problem Decomposition Schema
+ */
+export const ProblemDecompositionSchema = z.object({
+  originalProblem: z.string(),
+  components: z.array(ProblemComponentSchema),
+  relationships: z.array(z.object({
+    from: z.string().uuid(),
+    to: z.string().uuid(),
+    type: z.enum(['depends_on', 'blocks', 'enables', 'conflicts_with']),
+  })),
+  complexity: z.number().min(0).max(1),
+});
+
+/**
+ * Problem Decomposition Type
+ */
+export type ProblemDecomposition = z.infer<typeof ProblemDecompositionSchema>;
+
+/**
+ * Reasoning Session Schema
+ */
+export const ReasoningSessionSchema = z.object({
+  id: z.string().uuid(),
+  request: ReasoningRequestSchema,
+  steps: z.array(ReasoningStepSchema),
+  hypotheses: z.array(HypothesisSchema),
+  chainOfThought: ChainOfThoughtSchema.optional(),
+  decomposition: ProblemDecompositionSchema.optional(),
+  analogies: z.array(AnalogySchema).default([]),
+  causalChains: z.array(CausalChainSchema).default([]),
+  counterfactuals: z.array(CounterfactualScenarioSchema).default([]),
+  conclusion: z.string().optional(),
+  confidence: z.number().min(0).max(1),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Reasoning Session Type
+ */
+export type ReasoningSession = z.infer<typeof ReasoningSessionSchema>;
+
+/**
+ * Reasoning Result Schema
+ */
+export const ReasoningResultSchema = BaseResultSchema.extend({
+  session: ReasoningSessionSchema,
+  conclusion: z.string(),
+  recommendations: z.array(z.string()),
+  confidenceBreakdown: z.record(z.number().min(0).max(1)).default({}),
+});
+
+/**
+ * Reasoning Result Type
+ */
+export type ReasoningResult = z.infer<typeof ReasoningResultSchema>;

package/src/types/search.ts

@@ -0,0 +1,192 @@
+/**
+ * Search Types for gthinking v2.0.0
+ * Types for search and discovery functionality
+ */
+
+import { z } from 'zod';
+import { SourceType, BaseResultSchema } from './core';
+
+/**
+ * Search Provider Enum
+ */
+export enum SearchProvider {
+  GOOGLE = 'google',
+  BING = 'bing',
+  BRAVE = 'brave',
+  DUCKDUCKGO = 'duckduckgo',
+  KNOWLEDGE_BASE = 'knowledge_base',
+  CACHE = 'cache',
+}
+
+/**
+ * Search Provider Schema
+ */
+export const SearchProviderSchema = z.nativeEnum(SearchProvider);
+
+/**
+ * Search Query Schema
+ */
+export const SearchQuerySchema = z.object({
+  query: z.string().min(1).max(1000),
+  maxResults: z.number().positive().max(100).default(10),
+  sources: z.array(SearchProviderSchema).default([SearchProvider.GOOGLE]),
+  filters: z.object({
+    dateRange: z.object({
+      from: z.date().optional(),
+      to: z.date().optional(),
+    }).optional(),
+    language: z.string().default('en'),
+    region: z.string().optional(),
+    safeSearch: z.boolean().default(true),
+  }).default({}),
+  timeout: z.number().positive().default(30000),
+});
+
+/**
+ * Search Query Type
+ */
+export type SearchQuery = z.infer<typeof SearchQuerySchema>;
+
+/**
+ * Search Result Item Schema
+ */
+export const SearchResultItemSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string(),
+  url: z.string().url(),
+  snippet: z.string(),
+  source: SearchProviderSchema,
+  sourceType: z.nativeEnum(SourceType),
+  publishedDate: z.date().optional(),
+  credibility: z.number().min(0).max(1).default(0.5),
+  relevance: z.number().min(0).max(1).default(0.5),
+  engagement: z.number().min(0).max(1).default(0),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Search Result Item Type
+ */
+export type SearchResultItem = z.infer<typeof SearchResultItemSchema>;
+
+/**
+ * Search Result Schema
+ */
+export const SearchResultSchema = BaseResultSchema.extend({
+  query: SearchQuerySchema,
+  items: z.array(SearchResultItemSchema),
+  totalResults: z.number().nonnegative(),
+  searchTime: z.number().nonnegative(),
+  provider: SearchProviderSchema,
+});
+
+/**
+ * Search Result Type
+ */
+export type SearchResult = z.infer<typeof SearchResultSchema>;
+
+/**
+ * Aggregated Result Schema
+ */
+export const AggregatedResultSchema = z.object({
+  id: z.string().uuid(),
+  topic: z.string(),
+  summary: z.string(),
+  sources: z.array(SearchResultItemSchema),
+  consensusScore: z.number().min(0).max(1),
+  conflicts: z.array(z.object({
+    claim1: z.string(),
+    claim2: z.string(),
+    sources: z.array(z.string().uuid()),
+  })),
+  keyInsights: z.array(z.string()),
+  confidence: z.number().min(0).max(1),
+  timestamp: z.date(),
+});
+
+/**
+ * Aggregated Result Type
+ */
+export type AggregatedResult = z.infer<typeof AggregatedResultSchema>;
+
+/**
+ * Multi-Search Request Schema
+ */
+export const MultiSearchRequestSchema = z.object({
+  queries: z.array(z.string().min(1)).min(1).max(10),
+  options: SearchQuerySchema.shape.filters.default({}),
+});
+
+/**
+ * Multi-Search Request Type
+ */
+export type MultiSearchRequest = z.infer<typeof MultiSearchRequestSchema>;
+
+/**
+ * Search Cache Entry Schema
+ */
+export const SearchCacheEntrySchema = z.object({
+  key: z.string(),
+  query: SearchQuerySchema,
+  result: SearchResultSchema,
+  timestamp: z.date(),
+  ttl: z.number().positive(),
+  accessCount: z.number().nonnegative().default(0),
+});
+
+/**
+ * Search Cache Entry Type
+ */
+export type SearchCacheEntry = z.infer<typeof SearchCacheEntrySchema>;
+
+/**
+ * Knowledge Base Entry Schema
+ */
+export const KnowledgeBaseEntrySchema = z.object({
+  id: z.string().uuid(),
+  title: z.string(),
+  content: z.string(),
+  category: z.string(),
+  tags: z.array(z.string()),
+  credibility: z.number().min(0).max(1),
+  lastUpdated: z.date(),
+  source: z.string(),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Knowledge Base Entry Type
+ */
+export type KnowledgeBaseEntry = z.infer<typeof KnowledgeBaseEntrySchema>;
+
+/**
+ * Web Search Config Schema
+ */
+export const WebSearchConfigSchema = z.object({
+  provider: SearchProviderSchema,
+  apiKey: z.string().min(1),
+  baseUrl: z.string().url().optional(),
+  rateLimitPerSecond: z.number().positive().default(1),
+  maxRetries: z.number().nonnegative().default(3),
+  timeout: z.number().positive().default(10000),
+});
+
+/**
+ * Web Search Config Type
+ */
+export type WebSearchConfig = z.infer<typeof WebSearchConfigSchema>;
+
+/**
+ * Search Ranking Weights Schema
+ */
+export const SearchRankingWeightsSchema = z.object({
+  relevance: z.number().min(0).max(1).default(0.4),
+  credibility: z.number().min(0).max(1).default(0.3),
+  freshness: z.number().min(0).max(1).default(0.15),
+  engagement: z.number().min(0).max(1).default(0.15),
+});
+
+/**
+ * Search Ranking Weights Type
+ */
+export type SearchRankingWeights = z.infer<typeof SearchRankingWeightsSchema>;

package/src/types/synthesis.ts

@@ -0,0 +1,187 @@
+/**
+ * Synthesis Types for gthinking v2.0.0
+ * Types for synthesis and final output generation
+ */
+
+import { z } from 'zod';
+import { BaseResultSchema, ConfidenceLevel } from './core';
+
+/**
+ * Synthesis Request Schema
+ */
+export const SynthesisRequestSchema = z.object({
+  query: z.string().min(1),
+  stageResults: z.array(z.object({
+    stage: z.string(),
+    result: z.unknown(),
+    confidence: z.number().min(0).max(1),
+  })).min(1),
+  options: z.object({
+    includeDevilsAdvocate: z.boolean().default(true),
+    includeConfidenceBreakdown: z.boolean().default(true),
+    maxRecommendations: z.number().positive().default(5),
+    format: z.enum(['detailed', 'summary', 'structured', 'narrative']).default('detailed'),
+    language: z.string().default('en'),
+  }).default({}),
+});
+
+/**
+ * Synthesis Request Type
+ */
+export type SynthesisRequest = z.infer<typeof SynthesisRequestSchema>;
+
+/**
+ * Recommendation Schema
+ */
+export const RecommendationSchema = z.object({
+  id: z.string().uuid(),
+  priority: z.number().min(1).max(5),
+  title: z.string(),
+  description: z.string(),
+  rationale: z.string(),
+  confidence: z.number().min(0).max(1),
+  actions: z.array(z.string()),
+  expectedOutcome: z.string(),
+  risks: z.array(z.string()).default([]),
+  resources: z.array(z.string()).default([]),
+  timeline: z.string().optional(),
+});
+
+/**
+ * Recommendation Type
+ */
+export type Recommendation = z.infer<typeof RecommendationSchema>;
+
+/**
+ * Evaluation Result Schema
+ */
+export const EvaluationResultSchema = z.object({
+  criterion: z.string(),
+  score: z.number().min(0).max(1),
+  weight: z.number().min(0).max(1),
+  explanation: z.string(),
+  confidence: z.number().min(0).max(1),
+});
+
+/**
+ * Evaluation Result Type
+ */
+export type EvaluationResult = z.infer<typeof EvaluationResultSchema>;
+
+/**
+ * Devil's Advocate Point Schema
+ */
+export const DevilsAdvocatePointSchema = z.object({
+  id: z.string().uuid(),
+  target: z.string(), // What is being challenged
+  challenge: z.string(),
+  reasoning: z.string(),
+  severity: z.enum(['low', 'medium', 'high', 'critical']),
+  suggestedAlternative: z.string().optional(),
+  confidence: z.number().min(0).max(1),
+});
+
+/**
+ * Devil's Advocate Point Type
+ */
+export type DevilsAdvocatePoint = z.infer<typeof DevilsAdvocatePointSchema>;
+
+/**
+ * Confidence Breakdown Schema
+ */
+export const ConfidenceBreakdownSchema = z.object({
+  overall: z.number().min(0).max(1),
+  byStage: z.record(z.number().min(0).max(1)),
+  bySource: z.record(z.number().min(0).max(1)),
+  factors: z.array(z.object({
+    factor: z.string(),
+    impact: z.number().min(-1).max(1),
+    description: z.string(),
+  })),
+});
+
+/**
+ * Confidence Breakdown Type
+ */
+export type ConfidenceBreakdown = z.infer<typeof ConfidenceBreakdownSchema>;
+
+/**
+ * Synthesis Result Schema
+ */
+export const SynthesisResultSchema = BaseResultSchema.extend({
+  query: z.string(),
+  summary: z.string(),
+  keyFindings: z.array(z.string()),
+  recommendations: z.array(RecommendationSchema),
+  evaluation: z.array(EvaluationResultSchema),
+  devilsAdvocate: z.array(DevilsAdvocatePointSchema).default([]),
+  confidenceBreakdown: ConfidenceBreakdownSchema,
+  nextSteps: z.array(z.string()).default([]),
+  additionalConsiderations: z.array(z.string()).default([]),
+  sources: z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+    type: z.string(),
+    credibility: z.number().min(0).max(1),
+  })).default([]),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Synthesis Result Type
+ */
+export type SynthesisResult = z.infer<typeof SynthesisResultSchema>;
+
+/**
+ * Output Format Enum
+ */
+export enum OutputFormat {
+  JSON = 'json',
+  MARKDOWN = 'markdown',
+  HTML = 'html',
+  PLAIN = 'plain',
+  STRUCTURED = 'structured',
+}
+
+/**
+ * Output Format Schema
+ */
+export const OutputFormatSchema = z.nativeEnum(OutputFormat);
+
+/**
+ * Format Options Schema
+ */
+export const FormatOptionsSchema = z.object({
+  format: OutputFormatSchema.default(OutputFormat.MARKDOWN),
+  includeMetadata: z.boolean().default(false),
+  includeTimestamps: z.boolean().default(true),
+  includeConfidence: z.boolean().default(true),
+  maxLength: z.number().positive().optional(),
+  language: z.string().default('en'),
+  template: z.string().optional(),
+});
+
+/**
+ * Format Options Type
+ */
+export type FormatOptions = z.infer<typeof FormatOptionsSchema>;
+
+/**
+ * Formatted Output Schema
+ */
+export const FormattedOutputSchema = z.object({
+  content: z.string(),
+  format: OutputFormatSchema,
+  metadata: z.object({
+    generatedAt: z.date(),
+    version: z.string(),
+    confidence: z.number().min(0).max(1),
+    wordCount: z.number().nonnegative(),
+    charCount: z.number().nonnegative(),
+  }),
+});
+
+/**
+ * Formatted Output Type
+ */
+export type FormattedOutput = z.infer<typeof FormattedOutputSchema>;