@smekai/taskplanner 2.1.14

package/dist/model/config.d.ts

@@ -0,0 +1,15 @@
+import { TaskState } from './state.js';
+export interface TaskPlannerConfig {
+    version: number;
+    taskplannerVersion: string;
+    idPrefix: string;
+    nextId: number;
+    states: TaskState[];
+    priorities: string[];
+    tags: string[];
+    insertPosition: 'top' | 'bottom';
+    aiPlanRequired: boolean;
+    readmeAttribution: boolean;
+    sortBy: 'priority' | 'name' | 'id' | 'file';
+}
+export declare function createDefaultConfig(): TaskPlannerConfig;

package/dist/model/messages.d.ts

@@ -0,0 +1,65 @@
+import { Priority } from './task.js';
+/** Task data sent from extension host to webview */
+export interface TaskViewItem {
+    id: string;
+    title: string;
+    priority: Priority;
+    tags: string[];
+    epic?: string;
+    assignee?: string;
+    updatedAt?: string;
+    description: string;
+}
+export interface StateViewData {
+    name: string;
+    tasks: TaskViewItem[];
+    totalCount: number;
+    hasMore: boolean;
+}
+export interface TaskViewData {
+    states: StateViewData[];
+    filter?: TaskFilter;
+}
+/** Filter criteria for the task list */
+export interface TaskFilter {
+    status?: string;
+    query?: string;
+    tag?: string;
+    groupBy?: 'status' | 'assignee' | 'date' | 'none';
+}
+/** Grouped task view for the task list panel */
+export interface GroupViewData {
+    label: string;
+    tasks: TaskViewItem[];
+    totalCount: number;
+    hasMore: boolean;
+    collapsed?: boolean;
+}
+/** Messages from webview to extension host */
+export type WebviewMessage = {
+    type: 'ready';
+} | {
+    type: 'moveTask';
+    taskId: string;
+    targetState: string;
+    targetIndex?: number;
+} | {
+    type: 'reorderTask';
+    taskId: string;
+    newIndex: number;
+} | {
+    type: 'deleteTask';
+    taskId: string;
+} | {
+    type: 'openTask';
+    taskId: string;
+} | {
+    type: 'applyFilter';
+    filter: TaskFilter;
+} | {
+    type: 'showAll';
+    stateName?: string;
+} | {
+    type: 'expandGroup';
+    groupLabel: string;
+};

package/dist/model/parseResult.d.ts

@@ -0,0 +1,9 @@
+import { Task } from './task.js';
+export interface ParseWarning {
+    line: number;
+    message: string;
+}
+export interface ParseResult {
+    tasks: Task[];
+    warnings: ParseWarning[];
+}

package/dist/model/state.d.ts

@@ -0,0 +1,6 @@
+export interface TaskState {
+    name: string;
+    fileName: string;
+    order: number;
+}
+export declare const DEFAULT_STATES: TaskState[];

package/dist/model/task.d.ts

@@ -0,0 +1,19 @@
+export declare enum Priority {
+    P0 = "P0",
+    P1 = "P1",
+    P2 = "P2",
+    P3 = "P3",
+    P4 = "P4"
+}
+export interface Task {
+    id: string;
+    title: string;
+    description: string;
+    priority: Priority;
+    tags: string[];
+    epic?: string;
+    assignee?: string;
+    updatedAt?: string;
+    plan?: string;
+}
+export declare function isPriority(value: string): value is Priority;

package/dist/parser/taskParser.d.ts

@@ -0,0 +1,7 @@
+import { ParseResult } from '../model/parseResult.js';
+export declare function parseTasks(rawContent: string): ParseResult;
+export declare function findTaskLineNumber(content: string, taskId: string): number;
+/** Count `## PREFIX-###:` task headings without full parsing (for deferred state loads). */
+export declare function countTaskHeadings(rawContent: string): number;
+/** Highest numeric suffix among `## PREFIX-NNN:` headings in raw markdown, or 0 if none. */
+export declare function maxTaskIdNumber(rawContent: string, prefix: string): number;

package/dist/parser/taskSerializer.d.ts

@@ -0,0 +1,3 @@
+import { Task } from '../model/task.js';
+export declare function serializeTask(task: Task): string;
+export declare function serializeStateFile(stateName: string, tasks: Task[]): string;

package/dist/project/projectSync.d.ts

@@ -0,0 +1,26 @@
+import { ConfigManager } from '../config/configManager.js';
+export type VersionSyncStatus = 'installed-newer' | 'equal' | 'installed-older' | 'legacy' | 'invalid-installed';
+export interface VersionSyncComparison {
+    status: VersionSyncStatus;
+    installedVersion?: string;
+    storedVersion?: string;
+}
+export interface ProjectSyncOptions {
+    force?: boolean;
+    syncInstructions?: boolean;
+}
+export interface ProjectSyncResult extends VersionSyncComparison {
+    synchronized: boolean;
+    updatedFiles: string[];
+}
+/**
+ * Return a stable x.y.z version. SemVer build metadata, including +codex cachebusters,
+ * deliberately has no effect on project synchronization.
+ */
+export declare function normalizeTaskPlannerVersion(value: unknown): string | undefined;
+export declare function compareTaskPlannerVersions(installedValue: unknown, storedValue: unknown): VersionSyncComparison;
+/**
+ * Synchronize only TaskPlanner-owned marker blocks and safe config defaults.
+ * The recorded version is persisted last so an interrupted sync retries next time.
+ */
+export declare function synchronizeTaskPlannerProject(workspaceRoot: string, configManager: ConfigManager, installedValue: unknown, options?: ProjectSyncOptions): ProjectSyncResult;

package/dist/store/fileStore.d.ts

@@ -0,0 +1,18 @@
+import { Task } from '../model/task.js';
+import { TaskState } from '../model/state.js';
+import { TaskPlannerConfig } from '../model/config.js';
+import { ParseResult } from '../model/parseResult.js';
+export declare class FileStore {
+    private tasksDir;
+    constructor(tasksDir: string);
+    readState(state: TaskState): ParseResult;
+    writeState(state: TaskState, tasks: Task[]): void;
+    readAllStates(config: TaskPlannerConfig): Map<string, ParseResult>;
+    readStateAsync(state: TaskState): Promise<ParseResult>;
+    readRawContentAsync(state: TaskState): Promise<string>;
+    readAllStatesAsync(config: TaskPlannerConfig): Promise<Map<string, ParseResult>>;
+    ensureDirectory(): void;
+    initializeStateFiles(config: TaskPlannerConfig): void;
+    getStateFilePath(state: TaskState): string;
+    readRawContent(state: TaskState): string;
+}

package/dist/store/taskStore.d.ts

@@ -0,0 +1,70 @@
+import { Task } from '../model/task.js';
+import { TaskPlannerConfig } from '../model/config.js';
+import { ParseWarning } from '../model/parseResult.js';
+import { ConfigManager } from '../config/configManager.js';
+import { FileStore } from './fileStore.js';
+import { DuplicateResolution } from '../validation/duplicateDetector.js';
+export type TaskStoreListener = () => void;
+export declare function isDeferredStateName(stateName: string): boolean;
+export declare class TaskStore {
+    private configManager;
+    private tasksByState;
+    private parseWarningsByFile;
+    /** Done/Rejected not yet fully parsed; `tasksByState` holds [] until loaded. */
+    private deferredUnloadedStates;
+    /** Heading counts for deferred states (from `countTaskHeadings`). */
+    private deferredSectionCounts;
+    private listeners;
+    private fileStore;
+    private idGenerator;
+    constructor(configManager: ConfigManager, fileStore: FileStore);
+    get config(): TaskPlannerConfig;
+    reload(): void;
+    /** Reset in-memory state and deferred tracking to a blank slate before a reload. */
+    private resetReloadState;
+    /** Record a deferred state (raw counted only; tasks loaded lazily). */
+    private applyDeferredState;
+    /** Record a fully-parsed state's tasks and warnings. */
+    private applyParsedState;
+    private reloadSync;
+    reloadAsync(): Promise<void>;
+    /** Parse one state file into memory; clears deferred flag for that state. */
+    private parseStateIntoStore;
+    reloadState(stateName: string): void;
+    /** Load a deferred state (Done/Rejected) if it was not parsed yet. */
+    ensureStateLoaded(stateName: string): void;
+    /** Load every deferred state (e.g. assignee grouping, search, move picker). */
+    ensureAllDeferredStatesLoaded(): void;
+    /** Per-state counts for UI: heading count when deferred, else parsed task length. */
+    getStateDisplayCounts(): Map<string, number>;
+    isStateDeferredUnloaded(stateName: string): boolean;
+    getWarnings(): {
+        fileName: string;
+        warnings: ParseWarning[];
+    }[];
+    getTasksByState(stateName: string): Task[];
+    getAllTasks(): Map<string, Task[]>;
+    /**
+     * Highest task-ID number across every state. Loaded states read from memory;
+     * deferred states (Done/Rejected) scan raw file content so they stay deferred.
+     */
+    getMaxTaskIdNumber(): number;
+    private findInMemory;
+    findTask(taskId: string): {
+        task: Task;
+        stateName: string;
+    } | null;
+    createTask(task: Omit<Task, 'id'>, stateName: string): Task;
+    moveTask(taskId: string, targetStateName: string, targetIndex?: number): Task | null;
+    deleteTask(taskId: string): boolean;
+    updateTask(taskId: string, updates: Partial<Omit<Task, 'id'>>): Task | null;
+    private static hasChanges;
+    reorderTaskToIndex(taskId: string, newIndex: number): boolean;
+    reorderTask(taskId: string, direction: 'up' | 'down'): boolean;
+    onDidChange(listener: TaskStoreListener): {
+        dispose: () => void;
+    };
+    fixDuplicates(resolutions: DuplicateResolution[]): number;
+    private findState;
+    private notifyListeners;
+}

package/dist/util/time.d.ts

@@ -0,0 +1,2 @@
+/** Current timestamp in `YYYY-MM-DD HH:MM` form used in task `Updated:` metadata. */
+export declare function currentTimestamp(): string;

package/dist/validation/duplicateDetector.d.ts

@@ -0,0 +1,18 @@
+import { Task } from '../model/task.js';
+import { TaskState } from '../model/state.js';
+export interface DuplicateOccurrence {
+    stateName: string;
+    task: Task;
+    index: number;
+}
+export interface DuplicateConflict {
+    taskId: string;
+    occurrences: DuplicateOccurrence[];
+}
+export interface DuplicateResolution {
+    taskId: string;
+    keep: DuplicateOccurrence;
+    remove: DuplicateOccurrence[];
+}
+export declare function detectDuplicates(tasksByState: Map<string, Task[]>): DuplicateConflict[];
+export declare function resolveConflict(conflict: DuplicateConflict, states: TaskState[]): DuplicateResolution;

package/dist/view/boardViewModel.d.ts

@@ -0,0 +1,13 @@
+import type { TaskStore } from '../store/taskStore.js';
+import type { ConfigManager } from '../config/configManager.js';
+import type { TaskViewData } from '../model/messages.js';
+import { TaskListSortBy } from '../filter/taskFilter.js';
+export interface BuildBoardViewModelOptions {
+    searchQuery?: string;
+    sortBy?: TaskListSortBy;
+    /**
+     * Per-state cap. `undefined` uses the core default (50), `null` disables the cap.
+     */
+    limit?: number | null;
+}
+export declare function buildBoardViewModel(taskStore: TaskStore, configManager: ConfigManager, opts?: BuildBoardViewModelOptions): TaskViewData;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@smekai/taskplanner",
+  "version": "2.1.14",
+  "description": "TaskPlanner's markdown task board (.tasks/) as a library and as an MCP server.",
+  "license": "MIT",
+  "homepage": "https://github.com/smekai/taskplanner#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/smekai/taskplanner.git",
+    "directory": "packages/mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/smekai/taskplanner/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "taskplanner",
+    "tasks",
+    "kanban",
+    "markdown",
+    "agent"
+  ],
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./mcp-server": "./dist/mcp-server.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "taskplanner-mcp": "bin/taskplanner-mcp.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "ui/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}