@qoder-ai/qmind-cli 2.0.0 → 3.1.0

package/dist/management-BIYQa9Al.js

@@ -0,0 +1,313 @@
+import { X as voidResponseSchema, a as invalidArgument, c as optionalRecord, l as optionalString, m as requiredString, n as call, r as compactUndefined, s as optionalBoolean, t as assertNonEmptyPatch } from "./shared-BkQJzIZF.js";
+import { z } from "zod";
+//#region ../sdk/src/operations/management-schemas.ts
+const memberPermissionSchema = z.enum([
+	"owner",
+	"manage",
+	"edit",
+	"view"
+]);
+const notebookMemberSchema = z.object({
+	addedBy: z.string().default(""),
+	createdAt: z.string().default(""),
+	email: z.string().optional(),
+	id: z.string().min(1),
+	notebookId: z.string().default(""),
+	permission: memberPermissionSchema,
+	updatedAt: z.string().default(""),
+	userId: z.string().default("")
+});
+const notebookMemberListSchema = z.object({ members: z.array(notebookMemberSchema).nullish().transform((members) => members ?? []) });
+const scheduledTaskSceneSchema = z.enum([
+	"compilation",
+	"condensation",
+	"lint",
+	"source_refresh",
+	"source_binding_sync"
+]);
+const scheduledTaskSchema = z.object({
+	config: z.record(z.string(), z.unknown()).default({}),
+	createdAt: z.string().default(""),
+	enabled: z.boolean().default(true),
+	id: z.string().min(1),
+	lastRunAt: z.string().default(""),
+	nextRunAt: z.string().default(""),
+	notebookId: z.string().default(""),
+	sceneType: scheduledTaskSceneSchema,
+	schedule: z.string().default(""),
+	updatedAt: z.string().default(""),
+	userId: z.string().default("")
+});
+const scheduledTaskListSchema = z.object({ tasks: z.array(scheduledTaskSchema).nullish().transform((tasks) => tasks ?? []) });
+const compilationRunSchema = z.object({
+	compiledSourceCount: z.number().int().nonnegative().default(0),
+	createdAt: z.string().default(""),
+	finishedAt: z.string().default(""),
+	mode: z.enum([
+		"FULL",
+		"INCREMENTAL",
+		"REBUILD"
+	]),
+	percent: z.number().min(0).max(100).default(0),
+	publishedCardCount: z.number().int().nonnegative().default(0),
+	runId: z.string().min(1),
+	stage: z.string().optional(),
+	startedAt: z.string().default(""),
+	status: z.enum([
+		"PENDING",
+		"RUNNING",
+		"SUCCESS",
+		"PARTIAL",
+		"FAILED",
+		"CANCELED"
+	]),
+	templateId: z.string().default(""),
+	templateVersion: z.string().default(""),
+	trigger: z.enum([
+		"MANUAL",
+		"AUTO",
+		"SCHEDULED"
+	])
+});
+const compilationSettingsSchema = z.object({
+	additionalPrompt: z.string().optional(),
+	autoCompile: z.object({
+		debounceMinutes: z.union([z.literal(1), z.literal(30)]),
+		enabled: z.boolean()
+	}),
+	customPrompt: z.string().optional(),
+	customPromptConfigured: z.boolean().default(false),
+	effectiveTemplateVersion: z.string().default(""),
+	requiresRebuild: z.boolean().default(false),
+	selectedTemplateId: z.string().default(""),
+	templates: z.array(z.record(z.string(), z.unknown())).optional()
+});
+const compilationSettingsResponseSchema = z.object({ compilation: compilationSettingsSchema });
+const compilationRunResponseSchema = compilationRunSchema;
+const compilationStatusSchema = z.object({
+	activeRun: compilationRunSchema.optional(),
+	displayState: z.enum([
+		"UNCOMPILED",
+		"COMPILING",
+		"PARTIALLY_STALE",
+		"FAILED",
+		"COMPILED"
+	]),
+	effectiveEngine: z.string().default(""),
+	incrementalReady: z.boolean().default(false),
+	lastFailure: z.record(z.string(), z.unknown()).optional(),
+	lastSuccess: compilationRunSchema.optional(),
+	nextAutoCompileAt: z.string().default(""),
+	pendingChangeCount: z.number().int().nonnegative().default(0),
+	requiresRebuild: z.boolean().default(false)
+});
+//#endregion
+//#region ../sdk/src/operations/management.ts
+function memberPermission(value, field) {
+	if (value === "manage" || value === "edit" || value === "view") return value;
+	throw invalidArgument(`${field} must be manage, edit, or view`, field);
+}
+function scheduledTaskScene(value, field) {
+	if (value === "compilation" || value === "condensation" || value === "lint" || value === "source_refresh" || value === "source_binding_sync") return value;
+	throw invalidArgument(`${field} must be compilation, condensation, lint, source_refresh, or source_binding_sync`, field);
+}
+function compilationMode(value, field) {
+	if (value === "FULL" || value === "INCREMENTAL" || value === "REBUILD") return value;
+	throw invalidArgument(`${field} must be FULL, INCREMENTAL, or REBUILD`, field);
+}
+function autoCompilePatch(value) {
+	const record = optionalRecord(value, "compilation.autoCompile");
+	if (record === void 0) return void 0;
+	const enabled = optionalBoolean(record.enabled, "compilation.autoCompile.enabled");
+	const debounceMinutes = record.debounceMinutes;
+	if (debounceMinutes !== void 0 && debounceMinutes !== 1 && debounceMinutes !== 30) throw invalidArgument("compilation.autoCompile.debounceMinutes must be 1 or 30", "compilation.autoCompile.debounceMinutes");
+	const patch = compactUndefined({
+		debounceMinutes,
+		enabled
+	});
+	assertNonEmptyPatch(patch, "compilation.autoCompile");
+	return patch;
+}
+function createManagementOperations(context) {
+	return {
+		async addMember(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				body: {
+					email: requiredString(input?.email, "email"),
+					permission: memberPermission(input?.permission, "permission")
+				},
+				callOptions: options,
+				capability: "members",
+				idempotent: false,
+				method: "POST",
+				operation: "members.add",
+				path: context.profile.apiPath("notebooks", notebook, "members"),
+				schema: notebookMemberSchema
+			});
+		},
+		async createScheduledTask(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				body: compactUndefined({
+					config: optionalRecord(input?.config, "config"),
+					sceneType: scheduledTaskScene(input?.sceneType, "sceneType"),
+					schedule: requiredString(input?.schedule, "schedule")
+				}),
+				callOptions: options,
+				capability: "scheduledTasks",
+				idempotent: false,
+				method: "POST",
+				operation: "scheduledTasks.create",
+				path: context.profile.apiPath("notebooks", notebook, "scheduled-tasks"),
+				schema: scheduledTaskSchema
+			});
+		},
+		async deleteScheduledTask(notebookId, taskId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const task = requiredString(taskId, "taskId");
+			return call(context, {
+				callOptions: options,
+				capability: "scheduledTasks",
+				idempotent: false,
+				method: "DELETE",
+				operation: "scheduledTasks.delete",
+				path: context.profile.apiPath("notebooks", notebook, "scheduled-tasks", task),
+				schema: voidResponseSchema
+			});
+		},
+		async getCompilationSettings(notebookId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "compilation",
+				idempotent: true,
+				method: "GET",
+				operation: "compilation.settings.get",
+				path: context.profile.apiPath("notebooks", notebook, "compilation-settings"),
+				schema: compilationSettingsResponseSchema
+			});
+		},
+		async getCompilationStatus(notebookId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "compilation",
+				idempotent: true,
+				method: "GET",
+				operation: "compilation.status.get",
+				path: context.profile.apiPath("notebooks", notebook, "compilation-status"),
+				schema: compilationStatusSchema
+			});
+		},
+		async listMembers(notebookId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "members",
+				idempotent: true,
+				method: "GET",
+				operation: "members.list",
+				path: context.profile.apiPath("notebooks", notebook, "members"),
+				schema: notebookMemberListSchema
+			});
+		},
+		async listScheduledTasks(notebookId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "scheduledTasks",
+				idempotent: true,
+				method: "GET",
+				operation: "scheduledTasks.list",
+				path: context.profile.apiPath("notebooks", notebook, "scheduled-tasks"),
+				schema: scheduledTaskListSchema
+			});
+		},
+		async removeMember(notebookId, memberId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const member = requiredString(memberId, "memberId");
+			return call(context, {
+				callOptions: options,
+				capability: "members",
+				idempotent: false,
+				method: "DELETE",
+				operation: "members.remove",
+				path: context.profile.apiPath("notebooks", notebook, "members", member),
+				schema: voidResponseSchema
+			});
+		},
+		async saveCompilationSettings(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const compilation = optionalRecord(input?.compilation, "compilation");
+			if (compilation === void 0) throw invalidArgument("compilation must be an object", "compilation");
+			const patch = compactUndefined({
+				additionalPrompt: optionalString(compilation.additionalPrompt, "compilation.additionalPrompt"),
+				autoCompile: autoCompilePatch(compilation.autoCompile),
+				clearCustomPrompt: optionalBoolean(compilation.clearCustomPrompt, "compilation.clearCustomPrompt"),
+				customPrompt: optionalString(compilation.customPrompt, "compilation.customPrompt"),
+				templateId: optionalString(compilation.templateId, "compilation.templateId")
+			});
+			assertNonEmptyPatch(patch, "compilation");
+			return call(context, {
+				body: { compilation: patch },
+				callOptions: options,
+				capability: "compilation",
+				idempotent: false,
+				method: "PATCH",
+				operation: "compilation.settings.save",
+				path: context.profile.apiPath("notebooks", notebook, "compilation-settings"),
+				schema: compilationSettingsResponseSchema
+			});
+		},
+		async startCompilation(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				body: { mode: compilationMode(input?.mode, "mode") },
+				callOptions: options,
+				capability: "compilation",
+				idempotent: false,
+				method: "POST",
+				operation: "compilation.start",
+				path: context.profile.apiPath("notebooks", notebook, "compilations"),
+				schema: compilationRunResponseSchema
+			});
+		},
+		async updateMemberPermission(notebookId, memberId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const member = requiredString(memberId, "memberId");
+			return call(context, {
+				body: { permission: memberPermission(input?.permission, "permission") },
+				callOptions: options,
+				capability: "members",
+				idempotent: false,
+				method: "PUT",
+				operation: "members.update",
+				path: context.profile.apiPath("notebooks", notebook, "members", member),
+				schema: notebookMemberSchema
+			});
+		},
+		async updateScheduledTask(notebookId, taskId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const task = requiredString(taskId, "taskId");
+			const patch = compactUndefined({
+				config: optionalRecord(input?.config, "config"),
+				enabled: optionalBoolean(input?.enabled, "enabled"),
+				schedule: optionalString(input?.schedule, "schedule")
+			});
+			assertNonEmptyPatch(patch, "scheduledTask");
+			return call(context, {
+				body: patch,
+				callOptions: options,
+				capability: "scheduledTasks",
+				idempotent: false,
+				method: "PUT",
+				operation: "scheduledTasks.update",
+				path: context.profile.apiPath("notebooks", notebook, "scheduled-tasks", task),
+				schema: scheduledTaskSchema
+			});
+		}
+	};
+}
+//#endregion
+export { createManagementOperations };

package/dist/notes-BvucEfdi.js

@@ -0,0 +1,128 @@
+import { X as voidResponseSchema, Y as timestampSchema, c as optionalRecord, d as pagination, h as requiredText, l as optionalString, m as requiredString, n as call, p as queryPath, r as compactUndefined, t as assertNonEmptyPatch } from "./shared-BkQJzIZF.js";
+import { z } from "zod";
+//#region ../sdk/src/operations/note-schemas.ts
+const noteSchema = z.object({
+	content: z.string().default(""),
+	createdAt: timestampSchema.optional(),
+	id: z.string().min(1),
+	metadata: z.record(z.string(), z.unknown()).nullish(),
+	notebookId: z.string().default(""),
+	noteType: z.string().default(""),
+	orgId: z.string().default(""),
+	title: z.string().default(""),
+	updatedAt: timestampSchema.optional(),
+	userId: z.string().default("")
+});
+const noteListSchema = z.object({
+	currentPage: z.number().int().nonnegative().optional(),
+	notes: z.array(noteSchema).nullish().transform((notes) => notes ?? []),
+	pageSize: z.number().int().nonnegative().optional(),
+	totalSize: z.number().int().nonnegative().default(0)
+});
+//#endregion
+//#region ../sdk/src/operations/notes.ts
+function createNoteOperations(context) {
+	return {
+		async createNote(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const body = compactUndefined({
+				content: requiredText(input?.content, "content"),
+				metadata: optionalRecord(input?.metadata, "metadata"),
+				noteType: optionalString(input?.noteType, "noteType"),
+				title: requiredString(input?.title, "title")
+			});
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "notes.write",
+				idempotent: false,
+				method: "POST",
+				operation: "notes.create",
+				path: context.profile.apiPath("notebooks", notebook, "notes"),
+				schema: noteSchema
+			});
+		},
+		async deleteNote(notebookId, noteId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const note = requiredString(noteId, "noteId");
+			return call(context, {
+				callOptions: options,
+				capability: "notes.write",
+				idempotent: false,
+				method: "DELETE",
+				operation: "notes.delete",
+				path: context.profile.apiPath("notebooks", notebook, "notes", note),
+				schema: voidResponseSchema
+			});
+		},
+		async getNote(notebookId, noteId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const note = requiredString(noteId, "noteId");
+			return call(context, {
+				callOptions: options,
+				capability: "notes.read",
+				idempotent: true,
+				method: "GET",
+				operation: "notes.get",
+				path: context.profile.apiPath("notebooks", notebook, "notes", note),
+				schema: noteSchema
+			});
+		},
+		async listNotes(notebookId, input = {}, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const page = pagination({
+				page: input.page ?? 1,
+				pageSize: input.pageSize ?? 20
+			});
+			return call(context, {
+				callOptions: options,
+				capability: "notes.read",
+				idempotent: true,
+				method: "GET",
+				operation: "notes.list",
+				path: queryPath(context.profile.apiPath("notebooks", notebook, "notes"), [["page", page.page], ["page_size", page.pageSize]]),
+				schema: noteListSchema
+			});
+		},
+		async saveCondensationResult(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const body = {
+				content: requiredText(input?.content, "content"),
+				title: requiredString(input?.title, "title")
+			};
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "notes.saveCondensation",
+				idempotent: false,
+				method: "POST",
+				operation: "notes.saveCondensationResult",
+				path: context.profile.apiPath("notebooks", notebook, "condensation-results", "save"),
+				schema: noteSchema
+			});
+		},
+		async updateNote(notebookId, noteId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const note = requiredString(noteId, "noteId");
+			const body = compactUndefined({
+				content: optionalString(input?.content, "content"),
+				metadata: optionalRecord(input?.metadata, "metadata"),
+				noteType: optionalString(input?.noteType, "noteType"),
+				title: input?.title === void 0 ? void 0 : requiredString(input.title, "title")
+			});
+			assertNonEmptyPatch(body, "input");
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "notes.write",
+				idempotent: false,
+				method: "PUT",
+				operation: "notes.update",
+				path: context.profile.apiPath("notebooks", notebook, "notes", note),
+				schema: noteSchema
+			});
+		}
+	};
+}
+//#endregion
+export { createNoteOperations };