gthinking 1.2.1 → 2.1.1

package/src/types/learning.ts

@@ -0,0 +1,215 @@
+/**
+ * Learning Types for gthinking v2.0.0
+ * Types for learning and knowledge management functionality
+ */
+
+import { z } from 'zod';
+import { BaseResultSchema } from './core';
+
+/**
+ * Learning Context Schema
+ */
+export const LearningContextSchema = z.object({
+  id: z.string().uuid(),
+  sessionId: z.string(),
+  interactions: z.array(z.object({
+    id: z.string().uuid(),
+    query: z.string(),
+    response: z.string(),
+    timestamp: z.date(),
+    feedback: z.enum(['positive', 'negative', 'neutral']).optional(),
+    metadata: z.record(z.unknown()).default({}),
+  })).default([]),
+  patterns: z.array(z.object({
+    pattern: z.string(),
+    frequency: z.number().nonnegative(),
+    confidence: z.number().min(0).max(1),
+    lastSeen: z.date(),
+  })).default([]),
+  preferences: z.record(z.unknown()).default({}),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  lastAccessed: z.date(),
+});
+
+/**
+ * Learning Context Type
+ */
+export type LearningContext = z.infer<typeof LearningContextSchema>;
+
+/**
+ * Knowledge Node Schema
+ */
+export const KnowledgeNodeSchema = z.object({
+  id: z.string().uuid(),
+  concept: z.string(),
+  category: z.string(),
+  description: z.string(),
+  confidence: z.number().min(0).max(1),
+  sources: z.array(z.string()),
+  relatedNodes: z.array(z.string().uuid()).default([]),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  accessCount: z.number().nonnegative().default(0),
+  successRate: z.number().min(0).max(1).default(0.5),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Knowledge Node Type
+ */
+export type KnowledgeNode = z.infer<typeof KnowledgeNodeSchema>;
+
+/**
+ * Knowledge Edge Schema
+ */
+export const KnowledgeEdgeSchema = z.object({
+  id: z.string().uuid(),
+  from: z.string().uuid(),
+  to: z.string().uuid(),
+  relation: z.string(),
+  strength: z.number().min(0).max(1),
+  bidirectional: z.boolean().default(false),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Knowledge Edge Type
+ */
+export type KnowledgeEdge = z.infer<typeof KnowledgeEdgeSchema>;
+
+/**
+ * Knowledge Graph Schema
+ */
+export const KnowledgeGraphSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  nodes: z.array(KnowledgeNodeSchema),
+  edges: z.array(KnowledgeEdgeSchema),
+  categories: z.array(z.string()).default([]),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  version: z.number().positive().default(1),
+});
+
+/**
+ * Knowledge Graph Type
+ */
+export type KnowledgeGraph = z.infer<typeof KnowledgeGraphSchema>;
+
+/**
+ * Pattern Schema
+ */
+export const PatternSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  description: z.string(),
+  examples: z.array(z.string()),
+  frequency: z.number().nonnegative(),
+  confidence: z.number().min(0).max(1),
+  firstSeen: z.date(),
+  lastSeen: z.date(),
+  successRate: z.number().min(0).max(1).default(0.5),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Pattern Type
+ */
+export type Pattern = z.infer<typeof PatternSchema>;
+
+/**
+ * User Preference Schema
+ */
+export const UserPreferenceSchema = z.object({
+  id: z.string().uuid(),
+  category: z.string(),
+  key: z.string(),
+  value: z.unknown(),
+  confidence: z.number().min(0).max(1).default(0.5),
+  learnedFrom: z.array(z.string()).default([]),
+  updatedAt: z.date(),
+});
+
+/**
+ * User Preference Type
+ */
+export type UserPreference = z.infer<typeof UserPreferenceSchema>;
+
+/**
+ * Interaction Record Schema
+ */
+export const InteractionRecordSchema = z.object({
+  id: z.string().uuid(),
+  sessionId: z.string(),
+  query: z.string(),
+  response: z.string(),
+  thinkingStages: z.array(z.string()).default([]),
+  duration: z.number().nonnegative(),
+  timestamp: z.date(),
+  feedback: z.object({
+    rating: z.number().min(1).max(5).optional(),
+    comment: z.string().optional(),
+    helpful: z.boolean().optional(),
+  }).optional(),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Interaction Record Type
+ */
+export type InteractionRecord = z.infer<typeof InteractionRecordSchema>;
+
+/**
+ * Learning Result Schema
+ */
+export const LearningResultSchema = BaseResultSchema.extend({
+  context: LearningContextSchema.optional(),
+  patterns: z.array(PatternSchema).default([]),
+  preferences: z.array(UserPreferenceSchema).default([]),
+  relevantKnowledge: z.array(KnowledgeNodeSchema).default([]),
+  insights: z.array(z.string()).default([]),
+});
+
+/**
+ * Learning Result Type
+ */
+export type LearningResult = z.infer<typeof LearningResultSchema>;
+
+/**
+ * Persistence Config Schema
+ */
+export const PersistenceConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  strategy: z.enum(['memory', 'file', 'redis', 'database']).default('memory'),
+  autoSave: z.boolean().default(true),
+  autoSaveInterval: z.number().positive().default(60000), // 1 minute
+  maxContexts: z.number().positive().default(1000),
+  maxPatterns: z.number().positive().default(10000),
+  maxKnowledgeNodes: z.number().positive().default(50000),
+  ttl: z.number().positive().default(86400000), // 24 hours
+  compression: z.boolean().default(true),
+});
+
+/**
+ * Persistence Config Type
+ */
+export type PersistenceConfig = z.infer<typeof PersistenceConfigSchema>;
+
+/**
+ * Query Context Request Schema
+ */
+export const QueryContextRequestSchema = z.object({
+  query: z.string(),
+  sessionId: z.string().optional(),
+  maxInteractions: z.number().positive().default(10),
+  maxPatterns: z.number().positive().default(5),
+  maxKnowledgeNodes: z.number().positive().default(10),
+  includePreferences: z.boolean().default(true),
+  similarityThreshold: z.number().min(0).max(1).default(0.7),
+});
+
+/**
+ * Query Context Request Type
+ */
+export type QueryContextRequest = z.infer<typeof QueryContextRequestSchema>;

package/src/types/planning.ts

@@ -0,0 +1,251 @@
+/**
+ * Planning Types for gthinking v2.0.0
+ * Types for planning and task management functionality
+ */
+
+import { z } from 'zod';
+import { BaseResultSchema, Priority, TaskStatus } from './core';
+
+/**
+ * Planning Request Schema
+ */
+export const PlanningRequestSchema = z.object({
+  goal: z.string().min(1).max(5000),
+  constraints: z.object({
+    deadline: z.date().optional(),
+    budget: z.number().positive().optional(),
+    resources: z.array(z.string()).default([]),
+    dependencies: z.array(z.string()).default([]),
+    mustInclude: z.array(z.string()).default([]),
+    mustExclude: z.array(z.string()).default([]),
+  }).default({}),
+  options: z.object({
+    granularity: z.enum(['coarse', 'medium', 'fine']).default('medium'),
+    includeRisks: z.boolean().default(true),
+    includeTimeline: z.boolean().default(true),
+    maxTasks: z.number().positive().default(50),
+    bufferPercentage: z.number().min(0).max(50).default(20),
+  }).default({}),
+});
+
+/**
+ * Planning Request Type
+ */
+export type PlanningRequest = z.infer<typeof PlanningRequestSchema>;
+
+/**
+ * Task Schema
+ */
+export const TaskSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  description: z.string(),
+  status: z.nativeEnum(TaskStatus).default(TaskStatus.PENDING),
+  priority: z.nativeEnum(Priority).default(Priority.MEDIUM),
+  estimatedDuration: z.number().positive(), // in minutes
+  actualDuration: z.number().nonnegative().optional(),
+  complexity: z.number().min(0).max(1).default(0.5),
+  dependencies: z.array(z.string().uuid()).default([]),
+  subtasks: z.array(z.string().uuid()).default([]),
+  parentId: z.string().uuid().optional(),
+  assignedTo: z.string().optional(),
+  resources: z.array(z.string()).default([]),
+  tags: z.array(z.string()).default([]),
+  startDate: z.date().optional(),
+  endDate: z.date().optional(),
+  deadline: z.date().optional(),
+  progress: z.number().min(0).max(100).default(0),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Task Type
+ */
+export type Task = z.infer<typeof TaskSchema>;
+
+/**
+ * Milestone Schema
+ */
+export const MilestoneSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  description: z.string(),
+  dueDate: z.date(),
+  tasks: z.array(z.string().uuid()),
+  deliverables: z.array(z.string()),
+  completed: z.boolean().default(false),
+  completionDate: z.date().optional(),
+});
+
+/**
+ * Milestone Type
+ */
+export type Milestone = z.infer<typeof MilestoneSchema>;
+
+/**
+ * Resource Schema
+ */
+export const ResourceSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  type: z.enum(['human', 'material', 'financial', 'time', 'tool', 'service']),
+  capacity: z.number().positive(),
+  allocated: z.number().nonnegative().default(0),
+  costPerUnit: z.number().nonnegative().default(0),
+  unit: z.string().default('hours'),
+  availability: z.array(z.object({
+    from: z.date(),
+    to: z.date(),
+  })).default([]),
+  skills: z.array(z.string()).default([]),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Resource Type
+ */
+export type Resource = z.infer<typeof ResourceSchema>;
+
+/**
+ * Timeline Schema
+ */
+export const TimelineSchema = z.object({
+  startDate: z.date(),
+  endDate: z.date(),
+  duration: z.number().positive(), // in minutes
+  phases: z.array(z.object({
+    name: z.string(),
+    startDate: z.date(),
+    endDate: z.date(),
+    tasks: z.array(z.string().uuid()),
+  })),
+  criticalPath: z.array(z.string().uuid()),
+  buffer: z.number().nonnegative(), // in minutes
+  milestones: z.array(MilestoneSchema),
+});
+
+/**
+ * Timeline Type
+ */
+export type Timeline = z.infer<typeof TimelineSchema>;
+
+/**
+ * Risk Schema
+ */
+export const RiskSchema = z.object({
+  id: z.string().uuid(),
+  description: z.string(),
+  category: z.enum(['technical', 'schedule', 'budget', 'resource', 'external', 'operational']),
+  probability: z.number().min(0).max(1),
+  impact: z.number().min(0).max(1),
+  riskScore: z.number().min(0).max(1),
+  mitigation: z.array(z.string()).default([]),
+  contingency: z.string().optional(),
+  owner: z.string().optional(),
+  status: z.enum(['identified', 'monitoring', 'mitigated', 'occurred', 'resolved']).default('identified'),
+  triggers: z.array(z.string()).default([]),
+});
+
+/**
+ * Risk Type
+ */
+export type Risk = z.infer<typeof RiskSchema>;
+
+/**
+ * Plan Schema
+ */
+export const PlanSchema = z.object({
+  id: z.string().uuid(),
+  goal: z.string(),
+  description: z.string(),
+  tasks: z.array(TaskSchema),
+  timeline: TimelineSchema,
+  resources: z.array(ResourceSchema),
+  risks: z.array(RiskSchema),
+  assumptions: z.array(z.string()).default([]),
+  constraints: z.array(z.string()).default([]),
+  successCriteria: z.array(z.string()).default([]),
+  kpis: z.array(z.object({
+    metric: z.string(),
+    target: z.number(),
+    current: z.number().optional(),
+    unit: z.string(),
+  })).default([]),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  version: z.number().positive().default(1),
+  metadata: z.record(z.unknown()).default({}),
+});
+
+/**
+ * Plan Type
+ */
+export type Plan = z.infer<typeof PlanSchema>;
+
+/**
+ * Planning Result Schema
+ */
+export const PlanningResultSchema = BaseResultSchema.extend({
+  plan: PlanSchema,
+  alternatives: z.array(PlanSchema).default([]),
+  recommendations: z.array(z.string()).default([]),
+  warnings: z.array(z.string()).default([]),
+});
+
+/**
+ * Planning Result Type
+ */
+export type PlanningResult = z.infer<typeof PlanningResultSchema>;
+
+/**
+ * Progress Update Schema
+ */
+export const ProgressUpdateSchema = z.object({
+  taskId: z.string().uuid(),
+  progress: z.number().min(0).max(100),
+  status: z.nativeEnum(TaskStatus),
+  actualDuration: z.number().nonnegative().optional(),
+  notes: z.string().optional(),
+  blockers: z.array(z.string()).default([]),
+  timestamp: z.date(),
+});
+
+/**
+ * Progress Update Type
+ */
+export type ProgressUpdate = z.infer<typeof ProgressUpdateSchema>;
+
+/**
+ * Planning Stage Enum
+ */
+export enum PlanningStage {
+  INITIATION = 'initiation',
+  PLANNING = 'planning',
+  EXECUTION = 'execution',
+  MONITORING = 'monitoring',
+  CLOSING = 'closing',
+}
+
+/**
+ * Planning Stage Schema
+ */
+export const PlanningStageSchema = z.nativeEnum(PlanningStage);
+
+/**
+ * Task Decomposition Rule Schema
+ */
+export const TaskDecompositionRuleSchema = z.object({
+  id: z.string().uuid(),
+  pattern: z.string(), // regex pattern
+  subtasks: z.array(z.object({
+    template: z.string(),
+    estimatedDuration: z.number().positive(),
+    complexity: z.number().min(0).max(1),
+  })),
+  priority: z.nativeEnum(Priority),
+});
+
+/**
+ * Task Decomposition Rule Type
+ */
+export type TaskDecompositionRule = z.infer<typeof TaskDecompositionRuleSchema>;