@toloka-platform/sdk 0.1.0-preview.8 → 0.1.0

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";
@@ -238,7 +238,7 @@ export async function listRemoteProjects(options: {
       options.context?.id === project.id && options.context.alias !== undefined
         ? `\t${options.context.alias}`
         : "";
-    return `${mark}\t${project.id}\t${project.name}${alias}`;
+    return `${mark}\t${project.id}\t${project.name}\t${project.teamId}${alias}`;
   });
   if (page.pagination.hasMore) {
     lines.push(
@@ -250,6 +250,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;
 };
 
@@ -860,10 +864,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 +939,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/skill.ts

@@ -2,11 +2,9 @@ import { assert } from "es-toolkit";
 import { createHash } from "node:crypto";
 import { copyFile, mkdir, mkdtemp, readFile, realpath, rename, rm, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { assertSafeDestination, entryStats, hasErrorCode } from "./file-system";
 import { formatCliError } from "./format-error";
 
-export const BUNDLED_SKILL_CATALOG_ROOT = fileURLToPath(new URL("../../skills", import.meta.url));
 export const SKILL_CATALOG_MANIFEST = "catalog.json";
 export const SKILL_INSTALL_ROOT = ".agents/skills";
 export const SKILL_ENTRY_POINT = "SKILL.md";
@@ -133,15 +131,16 @@ export async function resolveBundledSkillCatalogRoot(
   const runtimeRoot =
     entry === undefined ? undefined : await findSkillCatalogRootAbove(dirname(entry));
   if (runtimeRoot !== undefined) return runtimeRoot;
+  const workingDirectoryRoot = await findSkillCatalogRootAbove(process.cwd());
   const searched =
     entry === undefined
       ? "process.argv[1] names no runtime entry"
       : `none exists between ${entry} and the filesystem root`;
   assert(
-    await isFileAt(join(BUNDLED_SKILL_CATALOG_ROOT, SKILL_CATALOG_MANIFEST)),
-    `Cannot locate the bundled skill catalog. An installed @toloka-platform/sdk must ship ${SKILL_CATALOG_DIRECTORY}/${SKILL_CATALOG_MANIFEST} in a directory above its runtime entry, but ${searched}, and the source checkout catalog ${BUNDLED_SKILL_CATALOG_ROOT} is absent. Reinstall @toloka-platform/sdk.`,
+    workingDirectoryRoot !== undefined,
+    `Cannot locate the bundled skill catalog. An installed @toloka-platform/sdk must ship ${SKILL_CATALOG_DIRECTORY}/${SKILL_CATALOG_MANIFEST} in a directory above its runtime entry, but ${searched}, and no ${SKILL_CATALOG_DIRECTORY}/${SKILL_CATALOG_MANIFEST} exists above ${process.cwd()} either. Reinstall @toloka-platform/sdk.`,
   );
-  return BUNDLED_SKILL_CATALOG_ROOT;
+  return workingDirectoryRoot;
 }
 
 const loadBundledSkillCatalog = async (): Promise<SkillCatalog> =>

package/src/cli/version.ts

@@ -0,0 +1,68 @@
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+
+import { assert } from "es-toolkit";
+import { SDK_VERSION } from "./init";
+
+export type CliInstallChannel = "global-registry" | "linked" | "project-local";
+
+type VersionInfoOptions = {
+  readonly globalBinDirectory?: string;
+  readonly globalPackageDirectory?: string;
+};
+
+const GLOBAL_PACKAGE_MARKER = `${sep}install${sep}global${sep}`;
+
+const realpathOrSelf = (path: string): string => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+};
+
+const classifyInstallChannel = (
+  entryPath: string,
+  packageRoot: string,
+  globalBinDirectory: string,
+  globalPackageDirectory: string,
+): CliInstallChannel => {
+  const resolvedEntryPath = realpathOrSelf(entryPath);
+  if (resolvedEntryPath.includes(GLOBAL_PACKAGE_MARKER)) return "global-registry";
+  if (realpathOrSelf(globalPackageDirectory) === packageRoot) return "linked";
+  if (dirname(resolve(entryPath)) === resolve(globalBinDirectory)) return "linked";
+  return "project-local";
+};
+
+export const cliVersionInfo = (entryPath = process.argv[1], options: VersionInfoOptions = {}) => {
+  assert(entryPath, "CLI entry path is unavailable");
+  const globalBinDirectory =
+    options.globalBinDirectory ??
+    resolve(process.env.BUN_INSTALL ?? join(homedir(), ".bun"), "bin");
+  const globalPackageDirectory =
+    options.globalPackageDirectory ??
+    resolve(
+      globalBinDirectory,
+      "..",
+      "install",
+      "global",
+      "node_modules",
+      "@toloka-platform",
+      "sdk",
+    );
+  const packageRoot = resolve(dirname(realpathOrSelf(entryPath)), "..");
+  const channel = classifyInstallChannel(
+    entryPath,
+    packageRoot,
+    globalBinDirectory,
+    globalPackageDirectory,
+  );
+
+  return {
+    version: SDK_VERSION,
+    commit: process.env.TOLOKA_BUILD_COMMIT ?? null,
+    channel,
+    ...(channel === "linked" ? { path: packageRoot } : {}),
+  };
+};

package/src/index.ts

@@ -69,6 +69,7 @@ export {
   connect,
   definePipeline,
   field,
+  optional,
   generation,
   isPipelineDefinition,
   match,
@@ -91,6 +92,7 @@ export type {
   InputPort,
   MatchAuthoringSettings,
   OutputPort,
+  OptionalFieldBinding,
   PipelineDefinition,
   PipelineDefinitionBindings,
   PipelineDefinitionInput,