@mulmoclaude/core 1.2.1 → 1.4.0

package/dist/google/tasks.d.ts

@@ -26,10 +26,31 @@ export interface CompleteTaskInput {
     taskId: string;
     taskListId?: string;
 }
+export interface UpdateTaskInput {
+    taskId: string;
+    title?: string;
+    /** `""` clears the notes; omit to leave them untouched. */
+    notes?: string;
+    /** RFC3339. Same DATE-only caveat as `CreateTaskInput.due`. Google rejects
+     *  `""`, so a due date can be changed but not removed through this call. */
+    due?: string;
+    taskListId?: string;
+}
 export declare const toTaskListSummary: (value: unknown) => TaskListSummary;
 export declare const toTaskSummary: (value: unknown) => TaskSummary;
+/** Resolve a declared taskListId to the one the API addresses. `||` (not `??`)
+ *  so a blank string also falls back instead of building a malformed
+ *  `/lists//tasks` URL — the same rule, and the same reason, as
+ *  `canonicalCalendarId`. */
+export declare const canonicalTaskListId: (taskListId: string | undefined) => string;
 export declare function listTaskLists(accessToken: string): Promise<TaskListSummary[]>;
 export declare function listTasks(accessToken: string, input?: ListTasksInput): Promise<TaskSummary[]>;
 export declare function createTask(accessToken: string, input: CreateTaskInput): Promise<TaskSummary>;
+/** PATCH body for a task edit — only the fields the caller supplied. As with
+ *  events, `undefined` means "leave as is" and `""` means "clear it", so the
+ *  two must stay distinct. `status` is deliberately absent: `completeTask`
+ *  owns that transition, and two ways to set it would drift apart. */
+export declare const buildTaskPatch: (input: UpdateTaskInput) => Record<string, unknown>;
+export declare function updateTask(accessToken: string, input: UpdateTaskInput): Promise<TaskSummary>;
 export declare function completeTask(accessToken: string, input: CompleteTaskInput): Promise<TaskSummary>;
 export declare function deleteTask(accessToken: string, input: CompleteTaskInput): Promise<void>;

package/dist/relPath-CgGi4-Nv.cjs

@@ -0,0 +1,46 @@
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+//#region src/files/relPath.ts
+/** Convert a host-shaped workspace-relative path to the POSIX form.
+*
+*  Splits on the host separator rather than rewriting every `\` — on POSIX a
+*  backslash is a legal filename character, so a blanket replace would turn the
+*  single directory `we\ird` into the two segments `we/ird` and send the write
+*  somewhere else. Splitting on `path.sep` is a no-op on POSIX and correct on
+*  Windows.
+*
+*  `sep` is a parameter so the Windows rule is assertable from a POSIX runner:
+*  bound to the host's own separator, the whole rule is invisible outside
+*  Windows CI, which is how the backslash form reached main twice (#2540).
+*
+*  Separator shape only — it neither validates nor contains. A traversal or a
+*  drive-absolute input survives as one, deliberately, so `resolveWithinRoot`
+*  downstream can still see the escape it has to refuse. */
+function toPosixRelPath(hostRelPath, sep = node_path.default.sep) {
+	return hostRelPath.split(sep).join("/");
+}
+/** Append a single path segment to a POSIX workspace-relative path.
+*
+*  Separate from `toPosixRelPath` because the inputs differ: this one joins
+*  segments that are ALREADY POSIX-shaped (a parent rel path plus one
+*  `Dirent.name`), so it must not touch the characters inside them. Use
+*  `toPosixRelPath` first when the parent came out of `node:path`. */
+function joinPosixRelPath(dirRelPosix, segment) {
+	return node_path.default.posix.join(dirRelPosix, segment);
+}
+//#endregion
+Object.defineProperty(exports, "joinPosixRelPath", {
+	enumerable: true,
+	get: function() {
+		return joinPosixRelPath;
+	}
+});
+Object.defineProperty(exports, "toPosixRelPath", {
+	enumerable: true,
+	get: function() {
+		return toPosixRelPath;
+	}
+});
+
+//# sourceMappingURL=relPath-CgGi4-Nv.cjs.map

package/dist/relPath-CgGi4-Nv.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"relPath-CgGi4-Nv.cjs","names":[],"sources":["../src/files/relPath.ts"],"sourcesContent":["// Workspace-relative paths are a POSIX contract (#2542). Every surface that\n// carries one — the Files tree, the upload response, the `file:` pubsub\n// channel, `<collection_paths>` in the agent prompt, export manifests, wiki\n// link hrefs — is `/`-separated on every host. Only the host filesystem layer\n// speaks `path.sep`.\n//\n// `node:path` produces host-shaped strings: `path.relative` / `path.join`\n// return `sub\\dir` on Windows. Anything derived from them has to cross back to\n// the POSIX contract before it leaves the filesystem layer, and this is where\n// that conversion is defined.\n\nimport path from \"node:path\";\n\n/** Convert a host-shaped workspace-relative path to the POSIX form.\n *\n *  Splits on the host separator rather than rewriting every `\\` — on POSIX a\n *  backslash is a legal filename character, so a blanket replace would turn the\n *  single directory `we\\ird` into the two segments `we/ird` and send the write\n *  somewhere else. Splitting on `path.sep` is a no-op on POSIX and correct on\n *  Windows.\n *\n *  `sep` is a parameter so the Windows rule is assertable from a POSIX runner:\n *  bound to the host's own separator, the whole rule is invisible outside\n *  Windows CI, which is how the backslash form reached main twice (#2540).\n *\n *  Separator shape only — it neither validates nor contains. A traversal or a\n *  drive-absolute input survives as one, deliberately, so `resolveWithinRoot`\n *  downstream can still see the escape it has to refuse. */\nexport function toPosixRelPath(hostRelPath: string, sep: string = path.sep): string {\n  return hostRelPath.split(sep).join(\"/\");\n}\n\n/** Append a single path segment to a POSIX workspace-relative path.\n *\n *  Separate from `toPosixRelPath` because the inputs differ: this one joins\n *  segments that are ALREADY POSIX-shaped (a parent rel path plus one\n *  `Dirent.name`), so it must not touch the characters inside them. Use\n *  `toPosixRelPath` first when the parent came out of `node:path`. */\nexport function joinPosixRelPath(dirRelPosix: string, segment: string): string {\n  return path.posix.join(dirRelPosix, segment);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,eAAe,aAAqB,MAAc,UAAA,QAAK,KAAa;CAClF,OAAO,YAAY,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG;AACxC;;;;;;;AAQA,SAAgB,iBAAiB,aAAqB,SAAyB;CAC7E,OAAO,UAAA,QAAK,MAAM,KAAK,aAAa,OAAO;AAC7C"}

package/dist/relPath-DW8MC8VO.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+//#region src/files/relPath.ts
+/** Convert a host-shaped workspace-relative path to the POSIX form.
+*
+*  Splits on the host separator rather than rewriting every `\` — on POSIX a
+*  backslash is a legal filename character, so a blanket replace would turn the
+*  single directory `we\ird` into the two segments `we/ird` and send the write
+*  somewhere else. Splitting on `path.sep` is a no-op on POSIX and correct on
+*  Windows.
+*
+*  `sep` is a parameter so the Windows rule is assertable from a POSIX runner:
+*  bound to the host's own separator, the whole rule is invisible outside
+*  Windows CI, which is how the backslash form reached main twice (#2540).
+*
+*  Separator shape only — it neither validates nor contains. A traversal or a
+*  drive-absolute input survives as one, deliberately, so `resolveWithinRoot`
+*  downstream can still see the escape it has to refuse. */
+function toPosixRelPath(hostRelPath, sep = path.sep) {
+	return hostRelPath.split(sep).join("/");
+}
+/** Append a single path segment to a POSIX workspace-relative path.
+*
+*  Separate from `toPosixRelPath` because the inputs differ: this one joins
+*  segments that are ALREADY POSIX-shaped (a parent rel path plus one
+*  `Dirent.name`), so it must not touch the characters inside them. Use
+*  `toPosixRelPath` first when the parent came out of `node:path`. */
+function joinPosixRelPath(dirRelPosix, segment) {
+	return path.posix.join(dirRelPosix, segment);
+}
+//#endregion
+export { toPosixRelPath as n, joinPosixRelPath as t };
+
+//# sourceMappingURL=relPath-DW8MC8VO.js.map

package/dist/relPath-DW8MC8VO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relPath-DW8MC8VO.js","names":[],"sources":["../src/files/relPath.ts"],"sourcesContent":["// Workspace-relative paths are a POSIX contract (#2542). Every surface that\n// carries one — the Files tree, the upload response, the `file:` pubsub\n// channel, `<collection_paths>` in the agent prompt, export manifests, wiki\n// link hrefs — is `/`-separated on every host. Only the host filesystem layer\n// speaks `path.sep`.\n//\n// `node:path` produces host-shaped strings: `path.relative` / `path.join`\n// return `sub\\dir` on Windows. Anything derived from them has to cross back to\n// the POSIX contract before it leaves the filesystem layer, and this is where\n// that conversion is defined.\n\nimport path from \"node:path\";\n\n/** Convert a host-shaped workspace-relative path to the POSIX form.\n *\n *  Splits on the host separator rather than rewriting every `\\` — on POSIX a\n *  backslash is a legal filename character, so a blanket replace would turn the\n *  single directory `we\\ird` into the two segments `we/ird` and send the write\n *  somewhere else. Splitting on `path.sep` is a no-op on POSIX and correct on\n *  Windows.\n *\n *  `sep` is a parameter so the Windows rule is assertable from a POSIX runner:\n *  bound to the host's own separator, the whole rule is invisible outside\n *  Windows CI, which is how the backslash form reached main twice (#2540).\n *\n *  Separator shape only — it neither validates nor contains. A traversal or a\n *  drive-absolute input survives as one, deliberately, so `resolveWithinRoot`\n *  downstream can still see the escape it has to refuse. */\nexport function toPosixRelPath(hostRelPath: string, sep: string = path.sep): string {\n  return hostRelPath.split(sep).join(\"/\");\n}\n\n/** Append a single path segment to a POSIX workspace-relative path.\n *\n *  Separate from `toPosixRelPath` because the inputs differ: this one joins\n *  segments that are ALREADY POSIX-shaped (a parent rel path plus one\n *  `Dirent.name`), so it must not touch the characters inside them. Use\n *  `toPosixRelPath` first when the parent came out of `node:path`. */\nexport function joinPosixRelPath(dirRelPosix: string, segment: string): string {\n  return path.posix.join(dirRelPosix, segment);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA4BA,SAAgB,eAAe,aAAqB,MAAc,KAAK,KAAa;CAClF,OAAO,YAAY,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG;AACxC;;;;;;;AAQA,SAAgB,iBAAiB,aAAqB,SAAyB;CAC7E,OAAO,KAAK,MAAM,KAAK,aAAa,OAAO;AAC7C"}

package/dist/{server-BZJCw2HU.js → server-D_6FLygK.js}

@@ -1,8 +1,10 @@
 import { t as errorMessage } from "./dist-Cwk0e12G.js";
 import { t as writeFileAtomic } from "./atomic-DPpdrJzO.js";
+import { n as toPosixRelPath } from "./relPath-DW8MC8VO.js";
 import { c as COMPUTED_TYPES, d as embedTargetId, f as isFieldDrivenEvery, g as fieldTextOrNull, h as fieldText, m as storageKindFor } from "./ids-s4GfmE93.js";
 import { A as uniqueEmbedTargets, E as itemIsDone, F as rollupValue, L as actionVisible, M as backlinkRows, N as coerceNumeric, P as projectBacklinkRow, S as selectDynamicRecord, b as firstDateField, d as parseIsoDateTime, g as deriveAll, j as uniqueRefTargets, k as uniqueBacklinkSources, t as defangForPrompt, u as parseIsoDate, v as ownProp, x as resolveIcon } from "./promptSafety-CQ5Un4wi.js";
 import { $ as skillsStagingDir, F as resolveCreateItemId, G as archiveDir, H as resolveTemplatePath, J as getWorkspaceRoot, L as SCHEMA_FILE$1, M as isRegularFile, R as isContainedInRoot, S as queryCsv, T as CollectionQueryZ, V as resolveDataDir, W as safeSlugName, X as log, Y as isPresetSlug$1, c as resolveMutateSet, d as storeFor, f as checkpointSqliteDatabase, g as cacheDir, i as resolvePrimaryField, k as isBackendUnavailable, n as discoverCollections, r as loadCollection, s as CollectionSchemaZ, u as readOnlyRefusal, w as compileJsonlQuery, x as normalizeCsvValue } from "./discovery-CKR4TOX3.js";
+import { ingestStatePath } from "./feeds/paths.js";
 import { dataSkillDir, mirrorSkillWrite } from "./skill-bridge/index.js";
 import path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
@@ -136,7 +138,7 @@ function sanitizeDeep(value) {
 *  collections, so it reflects what the host actually reads/writes. */
 function promptPathsFor(collection, workspaceRoot) {
 	const rel = path.relative(workspaceRoot, collection.skillDir);
-	const skillDir = (rel === "" || rel.startsWith("..") ? collection.skillDir : rel).split(path.sep).join("/");
+	const skillDir = toPosixRelPath(rel === "" || rel.startsWith("..") ? collection.skillDir : rel);
 	return {
 		slug: collection.slug,
 		dataPath: collection.schema.dataPath ?? collection.schema.dataSource?.path ?? "",
@@ -1042,6 +1044,7 @@ function deleteTargets(collection, workspaceRoot) {
 		stagingSkillDir(workspaceRoot, collection.slug),
 		collection.skillDir,
 		collection.dataDir,
+		ingestStatePath(collection.slug, workspaceRoot),
 		...collection.storageFile !== void 0 ? [collection.storageFile] : []
 	];
 }
@@ -1154,6 +1157,7 @@ async function removeLocations(collection, workspaceRoot) {
 		force: true
 	});
 	await rmdir(path.dirname(collection.dataDir)).catch(() => void 0);
+	await rm(ingestStatePath(collection.slug, workspaceRoot), { force: true });
 	if (collection.storageFile !== void 0) {
 		await rm(collection.storageFile, { force: true });
 		await rm(`${collection.storageFile}-wal`, { force: true });
@@ -1924,4 +1928,4 @@ function makeManageCollectionTool(deps = {}) {
 //#endregion
 export { buildCollectionActionSeedPrompt as A, validateRecordObject as C, enrichItems as D, runCollectionQuery as E, readCustomViewHtml as M, readCustomViewI18n as N, runQueryOverRows as O, readSkillTemplate as P, validateCollectionRecords as S, recordFieldProblem as T, computeCollectionIcon as _, deleteCollection as a, applyMutateAction as b, computeSuccessor as c, isTriggerDue as d, maybeSpawnSuccessor as f, ONE_SECOND_MS as g, successorId as h, deleteCustomView as i, promptPathsFor as j, buildActionSeedPrompt as k, daysInMonth as l, resolveEvery as m, MAX_UNSELECTIVE_ITEMS as n, deleteCollectionRefusalMessage as o, parseCivil as p, makeManageCollectionTool as r, advanceTriggerDate as s, MAX_SCHEMA_ISSUES as t, formatCivil as u, buildWorkspaceOntology as v, compileRecordZ as w, firstMutateParamProblem as x, schemaRelations as y };
 
-//# sourceMappingURL=server-BZJCw2HU.js.map
+//# sourceMappingURL=server-D_6FLygK.js.map