classifyre-schemas 0.4.2__tar.gz

classifyre_schemas-0.4.2/.gitignore

@@ -0,0 +1,54 @@
+.idea/
+runner-logs/
+dumps/
+apps/web/playwright/.cache/
+**/__pycache__/
+*.py[cod]
+.secrets
+.claude/
+.codex/
+# Dependencies
+node_modules
+.pnp
+.pnp.js
+
+# Local env files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Testing
+coverage
+
+# Turbo
+.turbo
+
+# Vercel
+.vercel
+
+# Build Outputs
+.next/
+out/
+build
+dist
+classifyre/apps/web/playwright/.cache/
+apps/web/public/docs/
+
+# Python cache artifacts
+__pycache__/
+*.pyc
+# Debug
+npm-debug.log*
+
+# Misc
+.DS_Store
+*.pem
+
+# Generated API Types (regenerate from openapi.json)
+apps/web/lib/api/schema.ts
+apps/web/lib/api/schema.d.ts
+.tools/
+
+bin/act

classifyre_schemas-0.4.2/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: classifyre-schemas
+Version: 0.4.2
+Summary: Shared JSON schemas for Classifyre monorepo
+Requires-Python: >=3.12
+Requires-Dist: fastjsonschema==2.21.2

classifyre_schemas-0.4.2/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@workspace/schemas",
+  "version": "0.4.2",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./source-docs": "./src/source-docs.ts",
+    "./detector-docs": "./src/detector-docs.ts",
+    "./assistant": "./src/assistant.ts",
+    "./package.json": "./package.json",
+    "./all_input_sources": "./src/schemas/all_input_sources.json",
+    "./all_detectors": "./src/schemas/all_detectors.ts",
+    "./single_asset_scan_results": "./src/schemas/single_asset_scan_results.json",
+    "./all_input_examples": "./src/schemas/all_input_examples.json",
+    "./all_detectors_examples": "./src/schemas/all_detectors_examples.ts",
+    "./assistant_knowledge": "./src/schemas/assistant_knowledge.json",
+    "./assistant_contexts": "./src/schemas/assistant_contexts.json"
+  },
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "scripts": {
+    "validate-examples": "uv run python scripts/validate_examples.py",
+    "codegen": "bun run validate-examples"
+  }
+}

classifyre_schemas-0.4.2/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "classifyre-schemas"
+version = "0.4.2"
+description = "Shared JSON schemas for Classifyre monorepo"
+requires-python = ">=3.12"
+dependencies = [
+    "fastjsonschema==2.21.2",
+]
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/schemas"]

classifyre_schemas-0.4.2/scripts/validate_examples.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Validate input examples against the input sources schema."""
+
+import json
+import sys
+from pathlib import Path
+
+import fastjsonschema
+
+# Map source type to schema definition name
+TYPE_TO_DEFINITION = {
+    "SLACK": "SlackInput",
+    "S3_COMPATIBLE_STORAGE": "S3CompatibleStorageInput",
+    "AZURE_BLOB_STORAGE": "AzureBlobStorageInput",
+    "GOOGLE_CLOUD_STORAGE": "GoogleCloudStorageInput",
+    "WORDPRESS": "WordPressInput",
+    "POSTGRESQL": "PostgreSQLInput",
+    "MYSQL": "MySQLInput",
+    "MSSQL": "MSSQLInput",
+    "ORACLE": "OracleInput",
+    "HIVE": "HiveInput",
+    "DATABRICKS": "DatabricksInput",
+    "SNOWFLAKE": "SnowflakeInput",
+    "MONGODB": "MongoDBInput",
+    "NEO4J": "Neo4jInput",
+    "POWERBI": "PowerBIInput",
+    "TABLEAU": "TableauInput",
+    "CONFLUENCE": "ConfluenceInput",
+    "JIRA": "JiraInput",
+    "SERVICEDESK": "ServiceDeskInput",
+}
+
+SCHEMAS_DIR = Path(__file__).parent.parent / "src" / "schemas"
+
+
+def load_schema():
+    """Load the input sources schema."""
+    schema_path = SCHEMAS_DIR / "all_input_sources.json"
+    with open(schema_path, "r") as f:
+        return json.load(f)
+
+
+def load_examples():
+    """Load the input examples."""
+    examples_path = SCHEMAS_DIR / "all_input_examples.json"
+    with open(examples_path, "r") as f:
+        return json.load(f)
+
+
+def create_validation_schema_for_type(schema: dict, source_type: str) -> dict:
+    """Create a validation schema for a specific source type."""
+    definition_name = TYPE_TO_DEFINITION.get(source_type)
+    if not definition_name:
+        raise ValueError(f"Unknown source type: {source_type}")
+
+    # Create a schema that references the specific input definition
+    return {
+        "$schema": schema.get("$schema", "http://json-schema.org/draft-07/schema#"),
+        "$ref": f"#/definitions/{definition_name}",
+        "definitions": schema.get("definitions", {}),
+    }
+
+
+def validate_examples():
+    """Validate all examples against the schema."""
+    schema = load_schema()
+    examples = load_examples()
+
+    errors = []
+    total_examples = 0
+    validated_examples = 0
+
+    for source_type, example_list in examples.items():
+        if not isinstance(example_list, list):
+            errors.append(f"Invalid format for {source_type}: expected array, got {type(example_list).__name__}")
+            continue
+
+        # Create validator for this source type
+        try:
+            type_schema = create_validation_schema_for_type(schema, source_type)
+            validator = fastjsonschema.compile(type_schema)
+        except ValueError as e:
+            # Skip types that don't have a schema definition
+            print(f"⚠️  Skipping {source_type}: {e}")
+            continue
+        except Exception as e:
+            errors.append(f"Failed to create validator for {source_type}: {e}")
+            continue
+
+        # Validate each example's config field
+        for idx, example in enumerate(example_list):
+            total_examples += 1
+            
+            # Validate example structure
+            if not isinstance(example, dict):
+                errors.append(f"{source_type}[{idx}]: Example must be an object")
+                continue
+            
+            if "name" not in example:
+                errors.append(f"{source_type}[{idx}]: Missing 'name' field")
+            if "description" not in example:
+                errors.append(f"{source_type}[{idx}]: Missing 'description' field")
+            if "config" not in example:
+                errors.append(f"{source_type}[{idx}]: Missing 'config' field")
+                continue
+            
+            # Validate config against schema
+            try:
+                validator(example["config"])
+                validated_examples += 1
+            except fastjsonschema.JsonSchemaException as e:
+                errors.append(f"{source_type}[{idx}] ({example.get('name', 'unnamed')}): {e.message}")
+            except Exception as e:
+                errors.append(f"{source_type}[{idx}] ({example.get('name', 'unnamed')}): Unexpected error: {e}")
+
+    # Print results
+    print(f"Validated {validated_examples}/{total_examples} examples")
+    
+    if errors:
+        print("\nValidation errors:")
+        for error in errors:
+            print(f"  ❌ {error}")
+        return False
+    
+    print("✅ All examples are valid!")
+    return True
+
+
+if __name__ == "__main__":
+    success = validate_examples()
+    sys.exit(0 if success else 1)

classifyre_schemas-0.4.2/src/assistant.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+
+export const assistantContextKeySchema = z.enum([
+  "source.create",
+  "source.edit",
+  "detector.create",
+  "semantic.glossary",
+  "semantic.metrics",
+]);
+
+export type AssistantContextKey = z.infer<typeof assistantContextKeySchema>;
+
+export const assistantOperationSchema = z.enum([
+  "create_source",
+  "update_source",
+  "test_source_connection",
+  "create_custom_detector",
+  "train_custom_detector",
+  "create_glossary_term",
+  "create_metric_definition",
+  "certify_metric",
+]);
+
+export type AssistantOperation = z.infer<typeof assistantOperationSchema>;
+
+export const assistantValidationStateSchema = z.object({
+  isValid: z.boolean(),
+  missingFields: z.array(z.string()),
+  errors: z.array(z.string()),
+});
+
+export type AssistantValidationState = z.infer<
+  typeof assistantValidationStateSchema
+>;
+
+export const assistantFieldPatchSchema = z.object({
+  path: z.string().min(1),
+  value: z.unknown(),
+});
+
+export type AssistantFieldPatch = z.infer<typeof assistantFieldPatchSchema>;
+
+export const assistantChatMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  content: z.string().min(1),
+});
+
+export type AssistantChatMessage = z.infer<typeof assistantChatMessageSchema>;
+
+export const assistantPageContextSchema = z.object({
+  key: assistantContextKeySchema,
+  route: z.string().min(1),
+  title: z.string().min(1),
+  entityId: z.string().nullable().optional(),
+  values: z.record(z.string(), z.unknown()),
+  schema: z.record(z.string(), z.unknown()).nullable().optional(),
+  validation: assistantValidationStateSchema,
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  supportedOperations: z.array(assistantOperationSchema),
+});
+
+export type AssistantPageContext = z.infer<typeof assistantPageContextSchema>;
+
+export const assistantPendingConfirmationSchema = z.object({
+  operation: assistantOperationSchema,
+  title: z.string().min(1),
+  detail: z.string().min(1),
+});
+
+export type AssistantPendingConfirmation = z.infer<
+  typeof assistantPendingConfirmationSchema
+>;
+
+const assistantToastActionSchema = z.object({
+  type: z.literal("show_toast"),
+  tone: z.enum(["info", "success", "error"]).default("info"),
+  title: z.string().min(1),
+  description: z.string().optional(),
+});
+
+const assistantPatchFieldsActionSchema = z.object({
+  type: z.literal("patch_fields"),
+  patches: z.array(assistantFieldPatchSchema).min(1),
+});
+
+const assistantSyncSourceActionSchema = z.object({
+  type: z.literal("sync_source"),
+  sourceId: z.string().uuid(),
+  values: z.record(z.string(), z.unknown()),
+  schedule: z
+    .object({
+      enabled: z.boolean(),
+      cron: z.string().optional(),
+      timezone: z.string().optional(),
+    })
+    .optional(),
+});
+
+const assistantSyncDetectorActionSchema = z.object({
+  type: z.literal("sync_detector"),
+  detectorId: z.string().uuid(),
+  values: z.record(z.string(), z.unknown()),
+});
+
+const assistantSyncGlossaryTermActionSchema = z.object({
+  type: z.literal("sync_glossary_term"),
+  termId: z.string(),
+  values: z.record(z.string(), z.unknown()),
+});
+
+const assistantSyncMetricActionSchema = z.object({
+  type: z.literal("sync_metric"),
+  metricId: z.string(),
+  values: z.record(z.string(), z.unknown()),
+});
+
+const assistantAttachResultActionSchema = z.object({
+  type: z.literal("attach_result"),
+  kind: z.enum(["source_test", "detector_train", "operation"]),
+  title: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()),
+});
+
+export const assistantUiActionSchema = z.discriminatedUnion("type", [
+  assistantToastActionSchema,
+  assistantPatchFieldsActionSchema,
+  assistantSyncSourceActionSchema,
+  assistantSyncDetectorActionSchema,
+  assistantSyncGlossaryTermActionSchema,
+  assistantSyncMetricActionSchema,
+  assistantAttachResultActionSchema,
+]);
+
+export type AssistantUiAction = z.infer<typeof assistantUiActionSchema>;
+
+export const assistantToolCallSummarySchema = z.object({
+  name: z.string().min(1),
+  status: z.enum(["success", "error"]),
+  detail: z.string().min(1),
+});
+
+export type AssistantToolCallSummary = z.infer<
+  typeof assistantToolCallSummarySchema
+>;
+
+export const assistantChatRequestSchema = z.object({
+  messages: z.array(assistantChatMessageSchema).min(1),
+  context: assistantPageContextSchema,
+  pendingConfirmation: assistantPendingConfirmationSchema.nullable().optional(),
+});
+
+export type AssistantChatRequest = z.infer<typeof assistantChatRequestSchema>;
+
+export const assistantChatResponseSchema = z.object({
+  reply: z.string().min(1),
+  actions: z.array(assistantUiActionSchema),
+  pendingConfirmation: assistantPendingConfirmationSchema.nullable(),
+  toolCalls: z.array(assistantToolCallSummarySchema),
+});
+
+export type AssistantChatResponse = z.infer<typeof assistantChatResponseSchema>;
+
+export const assistantContextRegistrySchema = z.record(
+  assistantContextKeySchema,
+  z.object({
+    title: z.string().min(1),
+    summary: z.string().min(1),
+    supportedOperations: z.array(assistantOperationSchema),
+  }),
+);
+
+export const assistantContexts = assistantContextRegistrySchema.parse({
+  "source.create": {
+    title: "Source Setup Assistant",
+    summary:
+      "Guide source creation, patch source fields, and confirm source creation or connection testing.",
+    supportedOperations: [
+      "create_source",
+      "update_source",
+      "test_source_connection",
+    ],
+  },
+  "source.edit": {
+    title: "Source Edit Assistant",
+    summary:
+      "Refine an existing source, patch source fields, and confirm updates or connection tests.",
+    supportedOperations: ["update_source", "test_source_connection"],
+  },
+  "detector.create": {
+    title: "Detector Studio Assistant",
+    summary:
+      "Brainstorm detector structure, patch detector fields, and confirm detector creation or training.",
+    supportedOperations: ["create_custom_detector", "train_custom_detector"],
+  },
+  "semantic.glossary": {
+    title: "Glossary Assistant",
+    summary:
+      "Help users define business glossary terms by describing what they want to track in plain language. Translate business intent into detector type filters, severity filters, and status filters.",
+    supportedOperations: ["create_glossary_term"],
+  },
+  "semantic.metrics": {
+    title: "Metrics Assistant",
+    summary:
+      "Help users create governed metrics by describing what they want to measure in plain language. Choose the right metric type (SIMPLE, RATIO, DERIVED, TREND) and build the definition.",
+    supportedOperations: ["create_metric_definition", "certify_metric"],
+  },
+});
+
+export type AssistantContextRegistry = typeof assistantContexts;