@tashks/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Simon W. Jackson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/query.d.ts

@@ -0,0 +1,294 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { type Task, type TaskEnergy } from "./schema.js";
+export declare const isBlocked: (task: Task, allTasks: Task[]) => boolean;
+export declare const isUnblocked: (task: Task, allTasks: Task[]) => boolean;
+export declare const isDueBefore: (date: string) => (task: Task) => boolean;
+export declare const isDueThisWeek: (today: string) => (task: Task) => boolean;
+export declare const isDeferred: (today: string) => (task: Task) => boolean;
+export declare const hasEnergy: (level: TaskEnergy) => (task: Task) => boolean;
+export declare const hasTag: (tag: string) => (task: Task) => boolean;
+export declare const hasProject: (project: string) => (task: Task) => boolean;
+export declare const isStalerThan: (
+	days: number,
+	today: string,
+) => (task: Task) => boolean;
+export declare const wasCompletedOn: (date: string) => (task: Task) => boolean;
+export declare const wasCompletedBetween: (
+	start: string,
+	end: string,
+) => (task: Task) => boolean;
+export declare const byDueAsc: (a: Task, b: Task) => number;
+export declare const byEnergyAsc: (a: Task, b: Task) => number;
+export declare const byCreatedAsc: (a: Task, b: Task) => number;
+export declare const byUpdatedDescThenTitle: (a: Task, b: Task) => number;
+export declare const resolveRelativeDate: (
+	value: string,
+	today: string,
+) => string | null;
+export declare const PerspectiveFilters: Schema.Struct<{
+	status: Schema.optionalWith<
+		Schema.Literal<
+			["active", "backlog", "blocked", "done", "dropped", "on-hold"]
+		>,
+		{
+			exact: true;
+		}
+	>;
+	area: Schema.optionalWith<
+		Schema.Literal<
+			[
+				"health",
+				"infrastructure",
+				"work",
+				"personal",
+				"blog",
+				"code",
+				"home",
+				"side-projects",
+			]
+		>,
+		{
+			exact: true;
+		}
+	>;
+	project: Schema.optionalWith<
+		typeof Schema.String,
+		{
+			exact: true;
+		}
+	>;
+	tags: Schema.optionalWith<
+		Schema.Array$<typeof Schema.String>,
+		{
+			exact: true;
+		}
+	>;
+	due_before: Schema.optionalWith<
+		typeof Schema.String,
+		{
+			exact: true;
+		}
+	>;
+	due_after: Schema.optionalWith<
+		typeof Schema.String,
+		{
+			exact: true;
+		}
+	>;
+	unblocked_only: Schema.optionalWith<
+		typeof Schema.Boolean,
+		{
+			exact: true;
+		}
+	>;
+	energy: Schema.optionalWith<
+		Schema.Literal<["low", "medium", "high"]>,
+		{
+			exact: true;
+		}
+	>;
+	stale_days: Schema.optionalWith<
+		typeof Schema.Number,
+		{
+			exact: true;
+		}
+	>;
+	completed_on: Schema.optionalWith<
+		typeof Schema.String,
+		{
+			exact: true;
+		}
+	>;
+}>;
+export type PerspectiveFilters = Schema.Schema.Type<typeof PerspectiveFilters>;
+export declare const PerspectiveSort: typeof Schema.String;
+export type PerspectiveSort = Schema.Schema.Type<typeof PerspectiveSort>;
+export declare const Perspective: Schema.Struct<{
+	filters: Schema.Struct<{
+		status: Schema.optionalWith<
+			Schema.Literal<
+				["active", "backlog", "blocked", "done", "dropped", "on-hold"]
+			>,
+			{
+				exact: true;
+			}
+		>;
+		area: Schema.optionalWith<
+			Schema.Literal<
+				[
+					"health",
+					"infrastructure",
+					"work",
+					"personal",
+					"blog",
+					"code",
+					"home",
+					"side-projects",
+				]
+			>,
+			{
+				exact: true;
+			}
+		>;
+		project: Schema.optionalWith<
+			typeof Schema.String,
+			{
+				exact: true;
+			}
+		>;
+		tags: Schema.optionalWith<
+			Schema.Array$<typeof Schema.String>,
+			{
+				exact: true;
+			}
+		>;
+		due_before: Schema.optionalWith<
+			typeof Schema.String,
+			{
+				exact: true;
+			}
+		>;
+		due_after: Schema.optionalWith<
+			typeof Schema.String,
+			{
+				exact: true;
+			}
+		>;
+		unblocked_only: Schema.optionalWith<
+			typeof Schema.Boolean,
+			{
+				exact: true;
+			}
+		>;
+		energy: Schema.optionalWith<
+			Schema.Literal<["low", "medium", "high"]>,
+			{
+				exact: true;
+			}
+		>;
+		stale_days: Schema.optionalWith<
+			typeof Schema.Number,
+			{
+				exact: true;
+			}
+		>;
+		completed_on: Schema.optionalWith<
+			typeof Schema.String,
+			{
+				exact: true;
+			}
+		>;
+	}>;
+	sort: Schema.optionalWith<
+		typeof Schema.String,
+		{
+			exact: true;
+		}
+	>;
+}>;
+export type Perspective = Schema.Schema.Type<typeof Perspective>;
+export declare const PerspectiveConfig: Schema.Record$<
+	typeof Schema.String,
+	Schema.Struct<{
+		filters: Schema.Struct<{
+			status: Schema.optionalWith<
+				Schema.Literal<
+					["active", "backlog", "blocked", "done", "dropped", "on-hold"]
+				>,
+				{
+					exact: true;
+				}
+			>;
+			area: Schema.optionalWith<
+				Schema.Literal<
+					[
+						"health",
+						"infrastructure",
+						"work",
+						"personal",
+						"blog",
+						"code",
+						"home",
+						"side-projects",
+					]
+				>,
+				{
+					exact: true;
+				}
+			>;
+			project: Schema.optionalWith<
+				typeof Schema.String,
+				{
+					exact: true;
+				}
+			>;
+			tags: Schema.optionalWith<
+				Schema.Array$<typeof Schema.String>,
+				{
+					exact: true;
+				}
+			>;
+			due_before: Schema.optionalWith<
+				typeof Schema.String,
+				{
+					exact: true;
+				}
+			>;
+			due_after: Schema.optionalWith<
+				typeof Schema.String,
+				{
+					exact: true;
+				}
+			>;
+			unblocked_only: Schema.optionalWith<
+				typeof Schema.Boolean,
+				{
+					exact: true;
+				}
+			>;
+			energy: Schema.optionalWith<
+				Schema.Literal<["low", "medium", "high"]>,
+				{
+					exact: true;
+				}
+			>;
+			stale_days: Schema.optionalWith<
+				typeof Schema.Number,
+				{
+					exact: true;
+				}
+			>;
+			completed_on: Schema.optionalWith<
+				typeof Schema.String,
+				{
+					exact: true;
+				}
+			>;
+		}>;
+		sort: Schema.optionalWith<
+			typeof Schema.String,
+			{
+				exact: true;
+			}
+		>;
+	}>
+>;
+export type PerspectiveConfig = Schema.Schema.Type<typeof PerspectiveConfig>;
+export declare const parsePerspectiveConfig: (
+	record: unknown,
+) => PerspectiveConfig | null;
+export declare const resolvePerspectiveConfigRelativeDates: (
+	config: PerspectiveConfig,
+	today: string,
+) => PerspectiveConfig | null;
+export declare const applyPerspectiveToTasks: (
+	tasks: ReadonlyArray<Task>,
+	perspective: Perspective,
+	today?: string,
+) => Array<Task>;
+export declare const loadPerspectiveConfig: (
+	dataDir: string,
+	today?: string,
+) => Effect.Effect<PerspectiveConfig, string>;
+//# sourceMappingURL=query.d.ts.map

package/dist/src/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/query.ts"],"names":[],"mappings":"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"}

package/dist/src/query.js

@@ -0,0 +1,303 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
+import * as Schema from "effect/Schema";
+import YAML from "yaml";
+import { TaskArea as TaskAreaSchema, TaskEnergy as TaskEnergySchema, TaskStatus as TaskStatusSchema, } from "./schema.js";
+const addDays = (date, days) => {
+    const next = new Date(`${date}T00:00:00.000Z`);
+    next.setUTCDate(next.getUTCDate() + days);
+    return next.toISOString().slice(0, 10);
+};
+const dateToUtcMidnight = (date) => {
+    const parsed = new Date(`${date}T00:00:00.000Z`).getTime();
+    return Number.isNaN(parsed) ? Number.NaN : parsed;
+};
+const completionDate = (task) => {
+    if (task.completed_at === null) {
+        return null;
+    }
+    const parsed = new Date(task.completed_at);
+    if (Number.isNaN(parsed.getTime())) {
+        return null;
+    }
+    return parsed.toISOString().slice(0, 10);
+};
+const perspectiveConfigFilePath = (dataDir) => join(dataDir, "perspectives.yaml");
+const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const isoDatePattern = /^\d{4}-\d{2}-\d{2}$/;
+const relativeDaysPattern = /^\+(\d+)d$/;
+const currentIsoDate = () => new Date().toISOString().slice(0, 10);
+const isIsoDate = (value) => {
+    if (!isoDatePattern.test(value)) {
+        return false;
+    }
+    const parsed = new Date(`${value}T00:00:00.000Z`);
+    if (Number.isNaN(parsed.getTime())) {
+        return false;
+    }
+    return parsed.toISOString().slice(0, 10) === value;
+};
+export const isBlocked = (task, allTasks) => {
+    if (task.blocked_by.length === 0) {
+        return false;
+    }
+    const taskById = new Map(allTasks.map((candidate) => [candidate.id, candidate]));
+    return task.blocked_by.some((blockerId) => {
+        const blocker = taskById.get(blockerId);
+        return blocker !== undefined && blocker.status !== "done";
+    });
+};
+export const isUnblocked = (task, allTasks) => !isBlocked(task, allTasks);
+export const isDueBefore = (date) => (task) => task.due !== null && task.due <= date;
+export const isDueThisWeek = (today) => {
+    const weekEnd = addDays(today, 7);
+    return (task) => task.due !== null && task.due >= today && task.due < weekEnd;
+};
+export const isDeferred = (today) => (task) => task.defer_until !== null && task.defer_until > today;
+export const hasEnergy = (level) => (task) => task.energy === level;
+export const hasTag = (tag) => (task) => task.tags.includes(tag);
+export const hasProject = (project) => (task) => task.project === project;
+export const isStalerThan = (days, today) => (task) => {
+    const updated = dateToUtcMidnight(task.updated);
+    const now = dateToUtcMidnight(today);
+    if (Number.isNaN(updated) || Number.isNaN(now)) {
+        return false;
+    }
+    const elapsedDays = (now - updated) / 86_400_000;
+    return elapsedDays > days;
+};
+export const wasCompletedOn = (date) => (task) => completionDate(task) === date;
+export const wasCompletedBetween = (start, end) => (task) => {
+    const completed = completionDate(task);
+    if (completed === null) {
+        return false;
+    }
+    return completed >= start && completed <= end;
+};
+const energyRank = {
+    low: 0,
+    medium: 1,
+    high: 2,
+};
+export const byDueAsc = (a, b) => {
+    if (a.due === null && b.due === null) {
+        return 0;
+    }
+    if (a.due === null) {
+        return 1;
+    }
+    if (b.due === null) {
+        return -1;
+    }
+    return a.due.localeCompare(b.due);
+};
+export const byEnergyAsc = (a, b) => energyRank[a.energy] - energyRank[b.energy];
+export const byCreatedAsc = (a, b) => a.created.localeCompare(b.created);
+export const byUpdatedDescThenTitle = (a, b) => {
+    const byUpdatedDesc = b.updated.localeCompare(a.updated);
+    if (byUpdatedDesc !== 0) {
+        return byUpdatedDesc;
+    }
+    return a.title.localeCompare(b.title);
+};
+const byUpdatedAscThenTitle = (a, b) => {
+    const byUpdatedAsc = a.updated.localeCompare(b.updated);
+    if (byUpdatedAsc !== 0) {
+        return byUpdatedAsc;
+    }
+    return a.title.localeCompare(b.title);
+};
+const byCompletedAtDescThenTitle = (a, b) => {
+    if (a.completed_at === null && b.completed_at === null) {
+        return a.title.localeCompare(b.title);
+    }
+    if (a.completed_at === null) {
+        return 1;
+    }
+    if (b.completed_at === null) {
+        return -1;
+    }
+    const byCompletedAtDesc = b.completed_at.localeCompare(a.completed_at);
+    if (byCompletedAtDesc !== 0) {
+        return byCompletedAtDesc;
+    }
+    return a.title.localeCompare(b.title);
+};
+export const resolveRelativeDate = (value, today) => {
+    const normalized = value.trim();
+    if (isIsoDate(normalized)) {
+        return normalized;
+    }
+    if (!isIsoDate(today)) {
+        return null;
+    }
+    if (normalized === "today") {
+        return today;
+    }
+    const relativeMatch = relativeDaysPattern.exec(normalized);
+    if (relativeMatch === null) {
+        return null;
+    }
+    const days = Number.parseInt(relativeMatch[1], 10);
+    return addDays(today, days);
+};
+export const PerspectiveFilters = Schema.Struct({
+    status: Schema.optionalWith(TaskStatusSchema, { exact: true }),
+    area: Schema.optionalWith(TaskAreaSchema, { exact: true }),
+    project: Schema.optionalWith(Schema.String, { exact: true }),
+    tags: Schema.optionalWith(Schema.Array(Schema.String), { exact: true }),
+    due_before: Schema.optionalWith(Schema.String, { exact: true }),
+    due_after: Schema.optionalWith(Schema.String, { exact: true }),
+    unblocked_only: Schema.optionalWith(Schema.Boolean, { exact: true }),
+    energy: Schema.optionalWith(TaskEnergySchema, { exact: true }),
+    stale_days: Schema.optionalWith(Schema.Number, { exact: true }),
+    completed_on: Schema.optionalWith(Schema.String, { exact: true }),
+});
+export const PerspectiveSort = Schema.String;
+export const Perspective = Schema.Struct({
+    filters: PerspectiveFilters,
+    sort: Schema.optionalWith(PerspectiveSort, { exact: true }),
+});
+export const PerspectiveConfig = Schema.Record({
+    key: Schema.String,
+    value: Perspective,
+});
+const decodePerspectiveConfigEither = Schema.decodeUnknownEither(PerspectiveConfig);
+export const parsePerspectiveConfig = (record) => {
+    const result = decodePerspectiveConfigEither(record);
+    return Either.isRight(result) ? result.right : null;
+};
+export const resolvePerspectiveConfigRelativeDates = (config, today) => {
+    const resolved = {};
+    for (const [name, perspective] of Object.entries(config)) {
+        const dueBefore = perspective.filters.due_before === undefined
+            ? undefined
+            : resolveRelativeDate(perspective.filters.due_before, today);
+        const dueAfter = perspective.filters.due_after === undefined
+            ? undefined
+            : resolveRelativeDate(perspective.filters.due_after, today);
+        const completedOn = perspective.filters.completed_on === undefined
+            ? undefined
+            : resolveRelativeDate(perspective.filters.completed_on, today);
+        if (dueBefore === null || dueAfter === null || completedOn === null) {
+            return null;
+        }
+        resolved[name] = {
+            ...perspective,
+            filters: {
+                ...perspective.filters,
+                ...(dueBefore !== undefined ? { due_before: dueBefore } : {}),
+                ...(dueAfter !== undefined ? { due_after: dueAfter } : {}),
+                ...(completedOn !== undefined ? { completed_on: completedOn } : {}),
+            },
+        };
+    }
+    return resolved;
+};
+export const applyPerspectiveToTasks = (tasks, perspective, today = currentIsoDate()) => {
+    const taskList = Array.from(tasks);
+    const dueBeforePredicate = perspective.filters.due_before !== undefined
+        ? isDueBefore(perspective.filters.due_before)
+        : null;
+    const stalePredicate = perspective.filters.stale_days !== undefined
+        ? isStalerThan(perspective.filters.stale_days, today)
+        : null;
+    const completedOnPredicate = perspective.filters.completed_on !== undefined
+        ? wasCompletedOn(perspective.filters.completed_on)
+        : null;
+    const filtered = taskList.filter((task) => {
+        if (perspective.filters.status !== undefined &&
+            task.status !== perspective.filters.status) {
+            return false;
+        }
+        if (perspective.filters.area !== undefined &&
+            task.area !== perspective.filters.area) {
+            return false;
+        }
+        if (perspective.filters.project !== undefined &&
+            task.project !== perspective.filters.project) {
+            return false;
+        }
+        if (perspective.filters.tags !== undefined &&
+            perspective.filters.tags.length > 0 &&
+            !perspective.filters.tags.some((tag) => task.tags.includes(tag))) {
+            return false;
+        }
+        if (perspective.filters.energy !== undefined &&
+            task.energy !== perspective.filters.energy) {
+            return false;
+        }
+        if (dueBeforePredicate !== null && !dueBeforePredicate(task)) {
+            return false;
+        }
+        if (perspective.filters.due_after !== undefined &&
+            (task.due === null || task.due < perspective.filters.due_after)) {
+            return false;
+        }
+        if (perspective.filters.unblocked_only === true &&
+            !isUnblocked(task, taskList)) {
+            return false;
+        }
+        if (stalePredicate !== null && !stalePredicate(task)) {
+            return false;
+        }
+        if (completedOnPredicate !== null && !completedOnPredicate(task)) {
+            return false;
+        }
+        return true;
+    });
+    switch (perspective.sort) {
+        case "due_asc":
+            return filtered.sort((a, b) => {
+                const byDue = byDueAsc(a, b);
+                return byDue !== 0 ? byDue : byUpdatedDescThenTitle(a, b);
+            });
+        case "energy_asc":
+            return filtered.sort((a, b) => {
+                const byEnergy = byEnergyAsc(a, b);
+                return byEnergy !== 0 ? byEnergy : byUpdatedDescThenTitle(a, b);
+            });
+        case "created_asc":
+            return filtered.sort((a, b) => {
+                const byCreated = byCreatedAsc(a, b);
+                return byCreated !== 0 ? byCreated : a.title.localeCompare(b.title);
+            });
+        case "updated_asc":
+            return filtered.sort(byUpdatedAscThenTitle);
+        case "completed_at_desc":
+            return filtered.sort(byCompletedAtDescThenTitle);
+        case "updated_desc":
+        default:
+            return filtered.sort(byUpdatedDescThenTitle);
+    }
+};
+export const loadPerspectiveConfig = (dataDir, today = currentIsoDate()) => Effect.tryPromise({
+    try: async () => {
+        const path = perspectiveConfigFilePath(dataDir);
+        const source = await readFile(path, "utf8").catch((error) => {
+            if (error !== null &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        });
+        if (source === null || source.trim().length === 0) {
+            return {};
+        }
+        const parsed = YAML.parse(source);
+        const config = parsePerspectiveConfig(parsed);
+        if (config === null) {
+            throw new Error(`Invalid perspective config in ${path}`);
+        }
+        const resolved = resolvePerspectiveConfigRelativeDates(config, today);
+        if (resolved === null) {
+            throw new Error(`Invalid perspective config in ${path}`);
+        }
+        return resolved;
+    },
+    catch: (error) => `Perspective config loader failed: ${toErrorMessage(error)}`,
+});

package/dist/src/query.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=query.test.d.ts.map

package/dist/src/query.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../../src/query.test.ts"],"names":[],"mappings":""}