@salesforce/graphiti 10.10.2

package/src/commands/meta.ts

@@ -0,0 +1,171 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { getSessionSchema } from "./query-helpers.js";
+import { formatHelp } from "../lib/query-commands.js";
+import {
+	loadSession,
+	getNavigationContext,
+	isInArgsContext,
+	queryNavToSchemaPath,
+	getArgsFieldPath,
+	getInputSubPath,
+	parseVariablePath,
+} from "../lib/session.js";
+import { formatPath } from "../lib/session.js";
+import {
+	getRootFields,
+	resolveArgByName,
+	resolveInputPath,
+	resolvePath,
+	type InputWalkerResult,
+} from "../lib/walker.js";
+
+export function queryExample(sessionId: string): void {
+	const session = loadSession(sessionId);
+	const ctx = getNavigationContext(session.navigationPath);
+	const schema = getSessionSchema(session);
+
+	if (ctx === "root" || session.navigationPath.length === 0) {
+		console.log("At root. Navigate into query/ or variables/:");
+		console.log("  cd query          — build the query projection");
+		console.log("  cd variables      — manage query variables");
+		return;
+	}
+
+	if (ctx === "variables") {
+		const varParsed = parseVariablePath(session.navigationPath);
+		if (!varParsed) {
+			console.log("Define and manage query variables:");
+			console.log("  define $filter AccountWhere      — create with explicit type");
+			console.log("  define $limit Int 10             — with a default value");
+			console.log("  define $filter @args/where       — auto-infer type from a path");
+			console.log("  cd $filter                       — navigate into a complex variable");
+			console.log("  assign $limit 10                 — set a scalar variable value");
+			return;
+		}
+		const variable = session.variables.find((v) => v.name === varParsed.varName);
+		if (!variable) return;
+		const rawType = variable.type.replace(/[![\]]/g, "");
+		const inputResult = resolveInputPath(schema, rawType, varParsed.inputSubPath);
+		printInputExamples(inputResult, "assign");
+		return;
+	}
+
+	if (isInArgsContext(session.navigationPath)) {
+		const fieldSchemaPath = getArgsFieldPath(session.navigationPath);
+		const inputSubPath = getInputSubPath(session.navigationPath);
+		const wr = resolvePath(schema, session.operation, fieldSchemaPath);
+
+		if (inputSubPath.length === 0) {
+			console.log(`Arguments for field at ${formatPath(fieldSchemaPath)}:`);
+			for (const arg of wr.args) {
+				const isLeaf = arg.typeKind === "SCALAR" || arg.typeKind === "ENUM";
+				if (isLeaf) {
+					console.log(`  assign ${arg.name} <value>       — ${arg.typeName}`);
+				} else {
+					console.log(`  cd ${arg.name}                   — navigate into ${arg.typeName}`);
+					console.log(`  assign ${arg.name} $var           — or bind a variable`);
+				}
+			}
+			console.log("");
+			console.log("  define $varName @args/where      — auto-infer type and bind");
+			console.log("  define $varName                  — auto-infer from current arg (after cd)");
+			return;
+		}
+
+		const argName = inputSubPath[0];
+		const argInfo = resolveArgByName(schema, wr, argName);
+		const rawType = argInfo.typeName;
+		const remaining = inputSubPath.slice(1);
+		const inputResult = resolveInputPath(schema, rawType, remaining);
+		printInputExamples(inputResult, "assign");
+		console.log("");
+		console.log("  define $varName                  — auto-infer type and bind to this position");
+		return;
+	}
+
+	const schemaPath = queryNavToSchemaPath(session.navigationPath);
+	if (schemaPath.length === 0) {
+		const rootFields = getRootFields(schema, session.operation);
+		console.log("Navigate into a field:");
+		for (const f of rootFields.slice(0, 5)) {
+			console.log(`  cd ${f.name}`);
+		}
+		return;
+	}
+
+	const wr = resolvePath(schema, session.operation, schemaPath);
+
+	console.log("Select leaf fields:");
+	const leaves = wr.fields.filter((f) => f.typeKind === "SCALAR" || f.typeKind === "ENUM");
+	for (const f of leaves.slice(0, 5)) {
+		const alias = f.name.charAt(0).toLowerCase() + f.name.slice(1);
+		console.log(`  select ${f.name}:${alias}`);
+	}
+
+	const dirs = wr.fields.filter((f) => f.typeKind !== "SCALAR" && f.typeKind !== "ENUM");
+	if (dirs.length > 0) {
+		console.log("");
+		console.log("Navigate into directories:");
+		for (const f of dirs.slice(0, 3)) {
+			console.log(`  cd ${f.name}`);
+		}
+	}
+
+	if (wr.args.length > 0) {
+		console.log("");
+		console.log("Configure arguments:");
+		console.log("  cd @args");
+	}
+
+	console.log("");
+	console.log("Create aliased instances:");
+	if (wr.fields.length > 0) {
+		const f = dirs[0] ?? wr.fields[0];
+		console.log(`  mkdir myAlias ${f.name}`);
+	}
+}
+
+export function printInputExamples(inputResult: InputWalkerResult, cmd: string): void {
+	if (inputResult.isList) {
+		console.log("List type — add elements with mkdir:");
+		console.log("  mkdir            — add a new element");
+		console.log("  cd 0             — navigate into element 0");
+		return;
+	}
+
+	const leaves = inputResult.inputFields.filter(
+		(f) => f.typeKind === "SCALAR" || f.typeKind === "ENUM",
+	);
+	const objs = inputResult.inputFields.filter(
+		(f) => f.typeKind !== "SCALAR" && f.typeKind !== "ENUM",
+	);
+
+	if (leaves.length > 0) {
+		console.log("Assign scalar fields:");
+		for (const f of leaves.slice(0, 5)) {
+			console.log(`  ${cmd} ${f.name} <value>        — ${f.typeName}`);
+		}
+	}
+	if (objs.length > 0) {
+		console.log("Navigate into nested types:");
+		for (const f of objs.slice(0, 3)) {
+			console.log(`  cd ${f.name}                   — ${f.typeName}`);
+		}
+	}
+}
+
+export function queryHelp(sessionId: string | undefined, topic?: string): void {
+	if (sessionId) {
+		try {
+			loadSession(sessionId);
+		} catch {
+			// Ignore — still show help even for invalid sessions.
+		}
+	}
+	console.log(formatHelp(topic));
+}

package/src/commands/navigate.ts

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any -- graphiti traverses untyped schema/introspection JSON; see follow-up to replace with `unknown` + narrowing */
+
+import {
+	CommandError,
+	getSessionSchema,
+	resolveDirectoryPathInSession,
+	resolveAliasSegments,
+	parsePathInput,
+	formatAliasContext,
+	detectSObjectName,
+	printDirectory,
+} from "./query-helpers.js";
+import { getOrgAuth } from "../lib/auth.js";
+import { formatNavigationPath, parseSearchTerms, parseSearchRegex } from "../lib/formatter.js";
+import { getObjectInfo } from "../lib/object-info.js";
+import {
+	loadSession,
+	saveSession,
+	syncFocusFromNavigationPath,
+	getNavigationContext,
+	isInArgsContext,
+	queryNavToSchemaPath,
+} from "../lib/session.js";
+import { getRootFields, resolvePath, type WalkerResult } from "../lib/walker.js";
+
+export function queryPwd(sessionId: string): void {
+	const session = loadSession(sessionId);
+	console.log(formatNavigationPath(session.navigationPath));
+	const aliasCtx = formatAliasContext(session);
+	if (aliasCtx) console.log(aliasCtx);
+}
+
+export async function queryLs(
+	sessionId: string,
+	opts: { search?: string; regex?: string; long?: boolean; all?: boolean; dataCloud?: boolean },
+	directories?: string[],
+): Promise<void> {
+	const session = loadSession(sessionId);
+
+	if (opts.long) {
+		const sObjectName = detectSObjectName(session);
+		if (sObjectName) {
+			try {
+				const auth = await getOrgAuth(session.orgAlias);
+				await getObjectInfo(auth, session.orgAlias, sObjectName);
+			} catch {
+				// Ignore — picklist values just won't be shown
+			}
+		}
+	}
+
+	if (directories && directories.length > 0) {
+		const schema = getSessionSchema(session);
+
+		for (const rawDir of directories) {
+			const dir =
+				rawDir.includes(".") && !rawDir.includes("/") ? rawDir.replace(/\./g, "/") : rawDir;
+			let resolved = parsePathInput(session.navigationPath, dir);
+			if (resolved.length > 0 && resolved[0] !== "query" && resolved[0] !== "variables") {
+				resolved = ["query", ...resolved];
+			}
+			resolved = resolveAliasSegments(session, resolved);
+			const ctx = getNavigationContext(resolved);
+
+			if (ctx === "variables" || isInArgsContext(resolved)) {
+				const tempSession = { ...session, navigationPath: resolved };
+				printDirectory(tempSession, opts);
+				continue;
+			}
+
+			const schemaPath = queryNavToSchemaPath(resolved);
+			if (schemaPath.length === 0) {
+				let rootFields = getRootFields(schema, session.operation);
+				const rootMatcher = opts.regex
+					? parseSearchRegex(opts.regex)
+					: opts.search
+						? parseSearchTerms(opts.search)
+						: undefined;
+				if (rootMatcher) {
+					rootFields = rootFields.filter((f) => rootMatcher.test(f.name));
+				}
+				console.log(`${rawDir}/`);
+				for (const f of rootFields) {
+					console.log(`  ${f.name}/`);
+				}
+				console.log("");
+				continue;
+			}
+
+			let wr: WalkerResult;
+			try {
+				wr = resolvePath(schema, session.operation, schemaPath);
+			} catch (e: any) {
+				console.log(`${rawDir}/ — ${e.message}`);
+				console.log("");
+				continue;
+			}
+			if (wr.isLeaf) {
+				console.log(`${rawDir}  (${wr.typeName}) — leaf field`);
+				console.log("");
+				continue;
+			}
+			console.log(`${rawDir}/`);
+			const tempSession = { ...session, navigationPath: resolved };
+			printDirectory(tempSession, { ...opts, all: opts.all || false });
+			console.log("");
+		}
+		return;
+	}
+
+	printDirectory(session, opts);
+}
+
+export function queryCd(sessionId: string, rawPath: string): void {
+	const session = loadSession(sessionId);
+	let nextPath: string[];
+
+	try {
+		nextPath = resolveDirectoryPathInSession(session, rawPath);
+	} catch (error: any) {
+		throw new CommandError(`Invalid path: ${error.message}`);
+	}
+
+	session.navigationPath = nextPath;
+	syncFocusFromNavigationPath(session);
+	saveSession(session);
+	console.log(formatNavigationPath(session.navigationPath));
+	printDirectory(session, { showFields: false });
+}