[crawler_platform 삭제]

ontology_platform/web/frontend/src/hooks/queryKeys.ts

@@ -0,0 +1,109 @@
+export const queryKeys = {
+  projects: {
+    all: ["projects"] as const,
+    list: () => [...queryKeys.projects.all, "list"] as const,
+    detail: (name: string) =>
+      [...queryKeys.projects.all, "detail", name] as const,
+  },
+  domains: {
+    all: ["domains"] as const,
+    list: () => [...queryKeys.domains.all, "list"] as const,
+  },
+  ontology: {
+    all: ["ontology"] as const,
+    byDomain: (domain: string) =>
+      [...queryKeys.ontology.all, "byDomain", domain] as const,
+  },
+  sources: {
+    all: ["sources"] as const,
+    byProject: (projectName: string) =>
+      [...queryKeys.sources.all, "byProject", projectName] as const,
+  },
+  crawl: {
+    all: ["crawl"] as const,
+    job: (jobId: string) =>
+      [...queryKeys.crawl.all, "job", jobId] as const,
+  },
+  research: {
+    all: ["research"] as const,
+    sessions: (projectName: string) =>
+      [...queryKeys.research.all, "sessions", projectName] as const,
+    session: (jobId: string) =>
+      [...queryKeys.research.all, "session", jobId] as const,
+  },
+  entities: {
+    all: ["entities"] as const,
+    list: (projectName: string, entityType?: string) =>
+      [
+        ...queryKeys.entities.all,
+        "list",
+        projectName,
+        entityType ?? "*",
+      ] as const,
+  },
+  claims: {
+    all: ["claims"] as const,
+    list: (projectName: string, status?: string, limit?: number) =>
+      [
+        ...queryKeys.claims.all,
+        "list",
+        projectName,
+        status ?? "*",
+        limit ?? "*",
+      ] as const,
+  },
+  platform: {
+    all: ["platform"] as const,
+    pipeline: (projectName: string) =>
+      [...queryKeys.platform.all, "pipeline", projectName] as const,
+    extractionLogs: (projectName: string, limit: number) =>
+      [
+        ...queryKeys.platform.all,
+        "extractionLogs",
+        projectName,
+        limit,
+      ] as const,
+    registry: (projectName: string) =>
+      [...queryKeys.platform.all, "registry", projectName] as const,
+    proposals: (projectName: string, limit: number) =>
+      [...queryKeys.platform.all, "proposals", projectName, limit] as const,
+    triples: (projectName: string, status: string, limit: number) =>
+      [
+        ...queryKeys.platform.all,
+        "triples",
+        projectName,
+        status,
+        limit,
+      ] as const,
+    graph: (
+      projectName: string,
+      entityId: string,
+      includeCandidates: boolean,
+      status: string,
+      limit: number,
+    ) =>
+      [
+        ...queryKeys.platform.all,
+        "graph",
+        projectName,
+        entityId,
+        includeCandidates,
+        status,
+        limit,
+      ] as const,
+    exportJson: (
+      projectName: string,
+      status: string,
+      includeEvidence: boolean,
+      limit: number,
+    ) =>
+      [
+        ...queryKeys.platform.all,
+        "exportJson",
+        projectName,
+        status,
+        includeEvidence,
+        limit,
+      ] as const,
+  },
+};

ontology_platform/web/frontend/src/hooks/useClaims.ts

@@ -0,0 +1,71 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { Claim, CreateClaimRequest, claimsApi } from "@/lib/api/claims";
+import { queryKeys } from "./queryKeys";
+
+export function useClaims(
+  projectName: string,
+  options: { status?: string; includeCandidates?: boolean; limit?: number } = {},
+) {
+  return useQuery<Claim[]>({
+    queryKey: queryKeys.claims.list(projectName, options.status, options.limit),
+    queryFn: () =>
+      claimsApi.list(projectName, {
+        status: options.status,
+        includeCandidates: options.includeCandidates,
+        limit: options.limit,
+      }),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useCreateClaim(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: CreateClaimRequest) =>
+      claimsApi.create(projectName, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.claims.all,
+      });
+    },
+  });
+}
+
+export function useDeleteClaim(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (claimId: string | number) =>
+      claimsApi.delete(projectName, claimId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.claims.all,
+      });
+    },
+  });
+}
+
+export function useUpdateClaimStatus(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      claimId,
+      status,
+      reason,
+    }: {
+      claimId: string | number;
+      status: string;
+      reason?: string | null;
+    }) => claimsApi.updateStatus(claimId, { status, reason }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.claims.all,
+      });
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.platform.all,
+      });
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.platform.pipeline(projectName),
+      });
+    },
+  });
+}

ontology_platform/web/frontend/src/hooks/useCrawl.ts

@@ -0,0 +1,44 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  CrawlJob,
+  crawlApi,
+  isCrawlTerminal,
+  StartSiteCrawlRequest,
+} from "@/lib/api/crawl";
+import { queryKeys } from "./queryKeys";
+
+const POLL_INTERVAL_MS = 2000;
+
+export function useStartSiteCrawl() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: StartSiteCrawlRequest) => crawlApi.startByProject(body),
+    onSuccess: (job) => {
+      queryClient.setQueryData(queryKeys.crawl.job(job.job_id), job);
+    },
+  });
+}
+
+export function useCrawlJob(jobId: string | null | undefined) {
+  return useQuery<CrawlJob>({
+    queryKey: queryKeys.crawl.job(jobId ?? ""),
+    queryFn: () => crawlApi.getJob(jobId!),
+    enabled: Boolean(jobId),
+    refetchInterval: (query) => {
+      const data = query.state.data as CrawlJob | undefined;
+      if (!data) return POLL_INTERVAL_MS;
+      return isCrawlTerminal(data.status) ? false : POLL_INTERVAL_MS;
+    },
+    refetchIntervalInBackground: false,
+  });
+}
+
+export function useCancelCrawl() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (jobId: string) => crawlApi.cancel(jobId),
+    onSuccess: (job) => {
+      queryClient.setQueryData(queryKeys.crawl.job(job.job_id), job);
+    },
+  });
+}

ontology_platform/web/frontend/src/hooks/useDomains.ts

@@ -0,0 +1,21 @@
+import { useQuery } from "@tanstack/react-query";
+import { domainsApi, DomainSummary } from "@/lib/api/domains";
+import { ontologyApi, OntologyDetail } from "@/lib/api/ontology";
+import { queryKeys } from "./queryKeys";
+
+export function useDomains() {
+  return useQuery<DomainSummary[]>({
+    queryKey: queryKeys.domains.list(),
+    queryFn: () => domainsApi.list(),
+    staleTime: 1000 * 60 * 30,
+  });
+}
+
+export function useOntology(domain: string | undefined) {
+  return useQuery<OntologyDetail>({
+    queryKey: queryKeys.ontology.byDomain(domain ?? ""),
+    queryFn: () => ontologyApi.get(domain!),
+    enabled: Boolean(domain),
+    staleTime: 1000 * 60 * 30,
+  });
+}

ontology_platform/web/frontend/src/hooks/useEntities.ts

@@ -0,0 +1,58 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  BulkCreateEntitiesRequest,
+  CreateEntityRequest,
+  entitiesApi,
+  Entity,
+} from "@/lib/api/entities";
+import { queryKeys } from "./queryKeys";
+
+export function useEntities(projectName: string, entityType?: string) {
+  return useQuery<Entity[]>({
+    queryKey: queryKeys.entities.list(projectName, entityType),
+    queryFn: () => entitiesApi.list(projectName, entityType),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useCreateEntity(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: CreateEntityRequest) =>
+      entitiesApi.create(projectName, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.entities.all,
+      });
+    },
+  });
+}
+
+export function useBulkCreateEntities(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: BulkCreateEntitiesRequest) =>
+      entitiesApi.bulkCreate(projectName, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.entities.all,
+      });
+    },
+  });
+}
+
+export function useDeleteEntity(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (entityId: string | number) =>
+      entitiesApi.delete(projectName, entityId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.entities.all,
+      });
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.claims.all,
+      });
+    },
+  });
+}

ontology_platform/web/frontend/src/hooks/usePlatform.ts

@@ -0,0 +1,146 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  CreateSchemaEntityTypeRequest,
+  CreateSchemaRelationTypeRequest,
+  ExtractionLog,
+  ExportJson,
+  GraphNeighborhood,
+  OntologyProposal,
+  OntologyRegistry,
+  OntologyTriple,
+  PipelineSummary,
+  RerunStageResponse,
+  platformApi,
+} from "@/lib/api/platform";
+import { queryKeys } from "./queryKeys";
+
+export function usePipeline(projectName: string) {
+  return useQuery<PipelineSummary>({
+    queryKey: queryKeys.platform.pipeline(projectName),
+    queryFn: () => platformApi.pipeline(projectName),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useExtractionLogs(projectName: string, limit = 50) {
+  return useQuery<ExtractionLog[]>({
+    queryKey: queryKeys.platform.extractionLogs(projectName, limit),
+    queryFn: () => platformApi.extractionLogs(projectName, limit),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useOntologyRegistry(projectName: string) {
+  return useQuery<OntologyRegistry>({
+    queryKey: queryKeys.platform.registry(projectName),
+    queryFn: () => platformApi.registry(projectName),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useOntologyProposals(projectName: string, limit = 100) {
+  return useQuery<OntologyProposal[]>({
+    queryKey: queryKeys.platform.proposals(projectName, limit),
+    queryFn: () => platformApi.proposals(projectName, limit),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useOntologyTriples(
+  projectName: string,
+  status?: string,
+  limit = 200,
+) {
+  return useQuery<OntologyTriple[]>({
+    queryKey: queryKeys.platform.triples(projectName, status ?? "*", limit),
+    queryFn: () => platformApi.triples(projectName, status, limit),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useGraphNeighborhood(
+  projectName: string,
+  options: {
+    entityId?: string | number | null;
+    includeCandidates?: boolean;
+    status?: string;
+    limit?: number;
+  } = {},
+) {
+  const entityKey = options.entityId == null ? "*" : String(options.entityId);
+  const statusKey = options.status ?? "*";
+  const limit = options.limit ?? 200;
+  return useQuery<GraphNeighborhood>({
+    queryKey: queryKeys.platform.graph(
+      projectName,
+      entityKey,
+      Boolean(options.includeCandidates),
+      statusKey,
+      limit,
+    ),
+    queryFn: () => platformApi.graphNeighborhood(projectName, options),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useExportJson(
+  projectName: string,
+  options: { status?: string; includeEvidence?: boolean; limit?: number } = {},
+) {
+  const status = options.status ?? "validated_claim";
+  const includeEvidence = options.includeEvidence ?? true;
+  const limit = options.limit ?? 1000;
+  return useQuery<ExportJson>({
+    queryKey: queryKeys.platform.exportJson(
+      projectName,
+      status,
+      includeEvidence,
+      limit,
+    ),
+    queryFn: () =>
+      platformApi.exportJson(projectName, {
+        status,
+        includeEvidence,
+        limit,
+      }),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useRerunPipelineStage(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation<RerunStageResponse, Error, string>({
+    mutationFn: (stage) => platformApi.rerunStage(projectName, stage),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.platform.pipeline(projectName),
+      });
+    },
+  });
+}
+
+export function useCreateSchemaEntityType(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: CreateSchemaEntityTypeRequest) =>
+      platformApi.createSchemaEntityType(projectName, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.platform.registry(projectName),
+      });
+    },
+  });
+}
+
+export function useCreateSchemaRelationType(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: CreateSchemaRelationTypeRequest) =>
+      platformApi.createSchemaRelationType(projectName, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.platform.registry(projectName),
+      });
+    },
+  });
+}

ontology_platform/web/frontend/src/hooks/useProjects.ts

@@ -0,0 +1,45 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  CreateProjectInlineRequest,
+  CreateProjectRequest,
+  projectsApi,
+  ProjectSummary,
+  ProjectDetail,
+} from "@/lib/api/projects";
+import { queryKeys } from "./queryKeys";
+
+export function useProjects() {
+  return useQuery<ProjectSummary[]>({
+    queryKey: queryKeys.projects.list(),
+    queryFn: () => projectsApi.list(),
+  });
+}
+
+export function useProject(name: string | undefined) {
+  return useQuery<ProjectDetail>({
+    queryKey: queryKeys.projects.detail(name ?? ""),
+    queryFn: () => projectsApi.detail(name!),
+    enabled: Boolean(name),
+  });
+}
+
+export function useCreateProject() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: CreateProjectRequest) => projectsApi.create(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.projects.all });
+    },
+  });
+}
+
+export function useCreateProjectInline() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: CreateProjectInlineRequest) =>
+      projectsApi.createInline(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.projects.all });
+    },
+  });
+}

ontology_platform/web/frontend/src/hooks/useResearch.ts

@@ -0,0 +1,37 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  researchApi,
+  ResearchRunResult,
+  ResearchSessionDetail,
+  ResearchSessionItem,
+  StartResearchRequest,
+} from "@/lib/api/research";
+import { queryKeys } from "./queryKeys";
+
+export function useStartResearch(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation<ResearchRunResult, Error, StartResearchRequest>({
+    mutationFn: (body) => researchApi.startByProject(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.research.sessions(projectName),
+      });
+    },
+  });
+}
+
+export function useResearchSessions(projectName: string, limit = 25) {
+  return useQuery<ResearchSessionItem[]>({
+    queryKey: queryKeys.research.sessions(projectName),
+    queryFn: () => researchApi.listSessions(projectName, limit),
+    enabled: Boolean(projectName),
+  });
+}
+
+export function useResearchSession(jobId: string | null | undefined) {
+  return useQuery<ResearchSessionDetail>({
+    queryKey: queryKeys.research.session(jobId ?? ""),
+    queryFn: () => researchApi.getSession(jobId!),
+    enabled: Boolean(jobId),
+  });
+}

ontology_platform/web/frontend/src/hooks/useSources.ts

@@ -0,0 +1,29 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { CreateSourceRequest, sourcesApi } from "@/lib/api/sources";
+import { queryKeys } from "./queryKeys";
+
+export function useCreateSource(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: CreateSourceRequest) =>
+      sourcesApi.create(projectName, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.projects.detail(projectName),
+      });
+    },
+  });
+}
+
+export function useDeleteSource(projectName: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (sourceName: string) =>
+      sourcesApi.delete(projectName, sourceName),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.projects.detail(projectName),
+      });
+    },
+  });
+}