@toloka-platform/sdk 0.1.0-preview.9 → 0.2.0-preview.1

package/src/cli/project-context.ts

@@ -1,5 +1,5 @@
 import { assert } from "es-toolkit";
-import { readTolokaState, writeTolokaState } from "../state";
+import { readTolokaState, TOLOKA_STATE_FILENAME, writeTolokaState } from "../state";
 import type { TolokaState } from "../state";
 import type { AuthPrompt } from "./auth";
 import type { TolokaCliFlags, TolokaEnvironment } from "./config";
@@ -35,10 +35,10 @@ export type ProjectCreateApi = {
 };
 
 export const MISSING_PROJECT_ID_MESSAGE =
-  "Missing project ID. Pass --project-id, set TOLOKA_PROJECT_ID, set projectId in toloka.json, or run toloka project add.";
+  "Missing project ID. Pass --project-id, set TOLOKA_PROJECT_ID, use a bound toloka.json, run toloka project create for a new project, or run toloka project add for an existing project.";
 
 export const NO_PROJECT_SELECTED_MESSAGE =
-  "No project selected. Run toloka project add, or cd into a checkout.";
+  "No project selected. Run toloka project create for a new project, toloka project add for an existing project, or cd into a checkout.";
 
 const NETWORK_MISMATCH_MESSAGE =
   "project add writes the machine registry; unset --api-key / --base-url / POTATO_API_KEY / POTATO_BASE_URL, or run login against that platform first.";
@@ -168,7 +168,8 @@ export const formatProjectContextLine = (
   project: ProjectContext | undefined,
   stored?: StoredCredentials,
 ): string => {
-  if (project === undefined) return "Project:  (none). Run toloka project add.";
+  if (project === undefined)
+    return "Project:  (none). Run toloka project create or toloka project add.";
   const alias = project.alias === undefined ? "" : `alias ${project.alias}, `;
   const registryNote =
     project.source !== "registry" && stored?.current !== undefined
@@ -232,14 +233,12 @@ export async function listRemoteProjects(options: {
 }): Promise<{ readonly output: string }> {
   const limit = options.limit ?? 20;
   const page = await options.client.projects.listPage({ limit });
-  const lines = page.projects.map((project) => {
-    const mark = options.context?.id === project.id ? "*" : " ";
-    const alias =
-      options.context?.id === project.id && options.context.alias !== undefined
-        ? `\t${options.context.alias}`
-        : "";
-    return `${mark}\t${project.id}\t${project.name}${alias}`;
+  const rows = page.projects.map((project) => {
+    const current = options.context?.id === project.id;
+    const alias = current ? (options.context.alias ?? "-") : "-";
+    return `${current ? "*" : "-"}\t${project.id}\t${project.name}\t${alias}`;
   });
+  const lines = rows.length === 0 ? [] : ["CURRENT\tID\tNAME\tALIAS", ...rows];
   if (page.pagination.hasMore) {
     lines.push(
       `Showing ${page.projects.length} of ${page.pagination.total} projects. Raise --limit to see more.`,
@@ -250,6 +249,51 @@ export async function listRemoteProjects(options: {
   return { output };
 }
 
+export type TrackedResourceKind = "pipeline" | "dataset";
+
+export async function untrackProjectResource(options: {
+  readonly sourceRoot: string;
+  readonly type: TrackedResourceKind;
+  readonly name: string;
+  readonly confirm: boolean;
+  readonly io: ProjectIo;
+}): Promise<{ readonly output: string }> {
+  const state = await readTolokaState(options.sourceRoot);
+  assert(state, `No ${TOLOKA_STATE_FILENAME} found in ${options.sourceRoot}.`);
+  const bindings = options.type === "pipeline" ? state.pipelines : state.datasets;
+  const binding = bindings[options.name];
+  assert(
+    binding,
+    `${options.type === "pipeline" ? "Pipeline" : "Dataset"} ${options.name} is not tracked.`,
+  );
+  const id = "pipelineId" in binding ? binding.pipelineId : binding.datasetId;
+  const label = `${options.type} ${options.name} (${id})`;
+
+  if (!options.confirm) {
+    assert(
+      options.io.prompt,
+      `Refusing to untrack ${label} without confirmation. Pass --confirm after reviewing ${TOLOKA_STATE_FILENAME}.`,
+    );
+    const answer = (
+      await options.io.prompt(`Untrack ${label}? The live resource will not be deleted. [y/N] `)
+    )
+      .trim()
+      .toLowerCase();
+    assert(answer === "y" || answer === "yes", "Untrack canceled.");
+  }
+
+  const remaining = Object.fromEntries(
+    Object.entries(bindings).filter(([candidate]) => candidate !== options.name),
+  );
+  await writeTolokaState(options.sourceRoot, {
+    ...state,
+    ...(options.type === "pipeline" ? { pipelines: remaining } : { datasets: remaining }),
+  });
+  const output = `Untracked ${label}. The live ${options.type} was not deleted.`;
+  options.io.stdout(output);
+  return { output };
+}
+
 export async function addProject(options: {
   readonly environment: CliEnvironment;
   readonly flags?: TolokaCliFlags;

package/src/cli/project.ts

@@ -4,6 +4,7 @@ import { dirname, join, resolve } from "node:path";
 import type {
   PipelineGraphSnapshot,
   PipelineGraphV1,
+  PipelineValidationIssue,
   PipelineValidationReport,
 } from "../../openapi/gen/models";
 import { resolvePipelineDefinition, validatePipelineDefinition } from "../authoring";
@@ -83,10 +84,13 @@ export type ApplyProjectResult = {
 
 export type ValidateProjectOptions = PlanProjectOptions;
 
+export type PipelineValidationStatus = "valid" | "invalid" | "checks_pending";
+
 export type PipelineValidationResult = {
   readonly sourceDirectory: string;
   readonly pipelineId?: string;
   readonly report?: PipelineValidationReport;
+  readonly status?: PipelineValidationStatus;
   readonly skipped?: string;
 };
 
@@ -844,10 +848,11 @@ export async function applyProject(
   if (valueKey(inspection.state) !== valueKey(nextState))
     await writeTolokaState(options.sourceRoot, nextState);
   const action = writes === 0 ? "unchanged" : "changed";
+  const plannedChanges = inspection.changes.length;
   const output =
     writes === 0
       ? "No changes."
-      : `Applied ${writes} ${writes === 1 ? "write" : "writes"} to project ${inspection.projectId}.`;
+      : `Applied ${plannedChanges} planned ${plannedChanges === 1 ? "change" : "changes"} with ${writes} platform ${writes === 1 ? "write" : "writes"} to project ${inspection.projectId}.`;
   return {
     action,
     state: nextState,
@@ -860,10 +865,47 @@ export async function applyProject(
 const issueLocation = (issue: { nodeId?: string; checkId?: string }) =>
   [issue.nodeId, issue.checkId].filter((value): value is string => value !== undefined).join("/");
 
+const PENDING_CHECK_CODE = "not_ran_node_check";
+
+const normalizeValidationIssue = (issue: PipelineValidationIssue): PipelineValidationIssue =>
+  issue.code === "empty_node_checks"
+    ? { ...issue, message: "No stored check cases are configured for this node" }
+    : issue;
+
+const normalizeValidationReport = (
+  report: PipelineValidationReport,
+): { readonly report: PipelineValidationReport; readonly status: PipelineValidationStatus } => {
+  const seen = new Set<string>();
+  const issues = report.issues.flatMap((rawIssue) => {
+    const issue = normalizeValidationIssue(rawIssue);
+    const key = [
+      issue.code,
+      issue.severity,
+      issue.nodeId ?? "",
+      issue.checkId ?? "",
+      issue.message,
+    ].join("\n");
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [issue];
+  });
+  const pending = issues.some((issue) => issue.code === PENDING_CHECK_CODE);
+  const blocking = issues.some(
+    (issue) => issue.severity === "error" && issue.code !== PENDING_CHECK_CODE,
+  );
+  const status: PipelineValidationStatus =
+    blocking || (!report.valid && !pending) ? "invalid" : pending ? "checks_pending" : "valid";
+  return {
+    status,
+    report: { ...report, valid: status !== "invalid", issues },
+  };
+};
+
 const formatValidationIssues = (report: PipelineValidationReport) =>
   report.issues.map((issue) => {
     const location = issueLocation(issue);
-    return `  ${issue.severity} ${issue.code}${location.length === 0 ? "" : ` ${location}`}: ${issue.message}`;
+    const severity = issue.code === PENDING_CHECK_CODE ? "pending" : issue.severity;
+    return `  ${severity} ${issue.code}${location.length === 0 ? "" : ` ${location}`}: ${issue.message}`;
   });
 
 export async function validateProject(
@@ -898,24 +940,26 @@ export async function validateProject(
             resolvePipelineDefinition(pipeline.source.definition, { datasetId: dataset.id }),
             pipeline.snapshot.graph,
           );
-    const report = await client.pipelines.validateGraph({
-      pipelineId: pipeline.pipeline.id,
-      graph,
-    });
+    const normalized = normalizeValidationReport(
+      await client.pipelines.validateGraph({
+        pipelineId: pipeline.pipeline.id,
+        graph,
+      }),
+    );
     results.push({
       sourceDirectory: pipeline.source.sourceDirectory,
       pipelineId: pipeline.pipeline.id,
-      report,
+      report: normalized.report,
+      status: normalized.status,
     });
   }
-  const valid = results.every((result) => result.report?.valid !== false);
+  const valid = results.every((result) => result.status !== "invalid");
   const lines = results.flatMap((result) => {
     if (result.skipped !== undefined)
       return [`- ${result.sourceDirectory}: skipped (${result.skipped})`];
     assert(result.report, `Pipeline ${result.sourceDirectory} is missing a validation report`);
-    const header = result.report.valid
-      ? `- ${result.sourceDirectory}: valid`
-      : `- ${result.sourceDirectory}: invalid`;
+    assert(result.status, `Pipeline ${result.sourceDirectory} is missing a validation status`);
+    const header = `- ${result.sourceDirectory}: ${result.status.replace("_", "-")}`;
     return [header, ...formatValidationIssues(result.report)];
   });
   return {

package/src/cli/secrets.ts

@@ -1,13 +1,13 @@
-import type { PipelineGraphV1 } from '../../openapi/gen/models';
+import type { PipelineGraphV1 } from "../../openapi/gen/models";
 
 export function collectGraphSecretNames(graph: {
-  readonly nodes: ReadonlyArray<PipelineGraphV1['nodes'][number]>;
+  readonly nodes: ReadonlyArray<PipelineGraphV1["nodes"][number]>;
 }): readonly string[] {
   const names = new Set<string>();
   for (const node of graph.nodes) {
-    if (node.type !== 'code') continue;
+    if (node.type !== "code") continue;
     for (const environmentVariable of node.settings.envVars ?? []) {
-      if (environmentVariable.type === 'secret') names.add(environmentVariable.secretName);
+      if (environmentVariable.type === "secret") names.add(environmentVariable.secretName);
     }
   }
   return [...names].toSorted((left, right) => left.localeCompare(right));