@agentuity/runtime 1.0.24 → 1.0.26

package/src/services/local/_db.ts

@@ -115,12 +115,20 @@ function initializeTables(db: Database): void {
 			created_id TEXT NOT NULL,
 			assigned_id TEXT,
 			closed_id TEXT,
+			deleted INTEGER NOT NULL DEFAULT 0,
 			created_at INTEGER NOT NULL,
 			updated_at INTEGER NOT NULL,
 			PRIMARY KEY (project_path, id)
 		)
 	`);
 
+	// Migration: add deleted column for existing databases
+	try {
+		db.run('ALTER TABLE task_storage ADD COLUMN deleted INTEGER NOT NULL DEFAULT 0');
+	} catch {
+		// Column already exists
+	}
+
 	// Task Changelog table
 	db.run(`
 		CREATE TABLE IF NOT EXISTS task_changelog_storage (
@@ -139,6 +147,57 @@ function initializeTables(db: Database): void {
 		CREATE INDEX IF NOT EXISTS idx_task_changelog_lookup
 		ON task_changelog_storage(project_path, task_id)
 	`);
+
+	// Task Comment table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS task_comment_storage (
+			project_path TEXT NOT NULL,
+			id TEXT NOT NULL,
+			task_id TEXT NOT NULL,
+			user_id TEXT NOT NULL,
+			body TEXT NOT NULL,
+			created_at INTEGER NOT NULL,
+			updated_at INTEGER NOT NULL,
+			PRIMARY KEY (project_path, id)
+		)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_task_comment_lookup
+		ON task_comment_storage(project_path, task_id)
+	`);
+
+	// Task Tag table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS task_tag_storage (
+			project_path TEXT NOT NULL,
+			id TEXT NOT NULL,
+			name TEXT NOT NULL,
+			color TEXT,
+			created_at INTEGER NOT NULL,
+			PRIMARY KEY (project_path, id)
+		)
+	`);
+
+	// Task-Tag association table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS task_tag_association_storage (
+			project_path TEXT NOT NULL,
+			task_id TEXT NOT NULL,
+			tag_id TEXT NOT NULL,
+			PRIMARY KEY (project_path, task_id, tag_id)
+		)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_task_tag_assoc_task
+		ON task_tag_association_storage(project_path, task_id)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_task_tag_assoc_tag
+		ON task_tag_association_storage(project_path, tag_id)
+	`);
 }
 
 function cleanupOrphanedProjects(db: Database): void {
@@ -163,14 +222,36 @@ function cleanupOrphanedProjects(db: Database): void {
 		.all() as Array<{
 		project_path: string;
 	}>;
+	const taskCommentPaths = db
+		.query('SELECT DISTINCT project_path FROM task_comment_storage')
+		.all() as Array<{
+		project_path: string;
+	}>;
+	const taskTagPaths = db
+		.query('SELECT DISTINCT project_path FROM task_tag_storage')
+		.all() as Array<{
+		project_path: string;
+	}>;
+	const taskTagAssocPaths = db
+		.query('SELECT DISTINCT project_path FROM task_tag_association_storage')
+		.all() as Array<{
+		project_path: string;
+	}>;
 
 	// Combine and deduplicate all project paths
 	const allPaths = new Set<string>();
-	[...kvPaths, ...streamPaths, ...vectorPaths, ...taskPaths, ...taskChangelogPaths].forEach(
-		(row) => {
-			allPaths.add(row.project_path);
-		}
-	);
+	[
+		...kvPaths,
+		...streamPaths,
+		...vectorPaths,
+		...taskPaths,
+		...taskChangelogPaths,
+		...taskCommentPaths,
+		...taskTagPaths,
+		...taskTagAssocPaths,
+	].forEach((row) => {
+		allPaths.add(row.project_path);
+	});
 
 	// Check which paths no longer exist and are not the current project
 	const pathsToDelete: string[] = [];
@@ -198,12 +279,24 @@ function cleanupOrphanedProjects(db: Database): void {
 		const deleteTaskChangelog = db.prepare(
 			`DELETE FROM task_changelog_storage WHERE project_path IN (${placeholders})`
 		);
+		const deleteTaskComments = db.prepare(
+			`DELETE FROM task_comment_storage WHERE project_path IN (${placeholders})`
+		);
+		const deleteTaskTags = db.prepare(
+			`DELETE FROM task_tag_storage WHERE project_path IN (${placeholders})`
+		);
+		const deleteTaskTagAssoc = db.prepare(
+			`DELETE FROM task_tag_association_storage WHERE project_path IN (${placeholders})`
+		);
 
 		deleteKv.run(...pathsToDelete);
 		deleteStream.run(...pathsToDelete);
 		deleteVector.run(...pathsToDelete);
 		deleteTasks.run(...pathsToDelete);
 		deleteTaskChangelog.run(...pathsToDelete);
+		deleteTaskComments.run(...pathsToDelete);
+		deleteTaskTags.run(...pathsToDelete);
+		deleteTaskTagAssoc.run(...pathsToDelete);
 
 		console.log(`[LocalDB] Cleaned up data for ${pathsToDelete.length} orphaned project(s)`);
 	}

package/src/services/local/email.ts

@@ -3,6 +3,7 @@ import {
 	type EmailService,
 	type EmailAddress,
 	type EmailDestination,
+	type EmailConnectionConfig,
 	type EmailInbound,
 	type EmailOutbound,
 	type EmailSendParams,
@@ -11,10 +12,7 @@ import {
 const ERROR_MESSAGE =
 	'Email service is not available in local development mode. Deploy to Agentuity Cloud to use email.';
 
-const LocalEmailNotAvailableError = StructuredError(
-	'LocalEmailNotAvailableError',
-	ERROR_MESSAGE
-);
+const LocalEmailNotAvailableError = StructuredError('LocalEmailNotAvailableError', ERROR_MESSAGE);
 
 /**
  * Local development stub for the email service.
@@ -33,6 +31,10 @@ export class LocalEmailStorage implements EmailService {
 		throw new LocalEmailNotAvailableError();
 	}
 
+	async getConnectionConfig(_id: string): Promise<EmailConnectionConfig | null> {
+		throw new LocalEmailNotAvailableError();
+	}
+
 	async deleteAddress(_id: string): Promise<void> {
 		throw new LocalEmailNotAvailableError();
 	}
@@ -65,6 +67,10 @@ export class LocalEmailStorage implements EmailService {
 		throw new LocalEmailNotAvailableError();
 	}
 
+	async deleteInbound(_id: string): Promise<void> {
+		throw new LocalEmailNotAvailableError();
+	}
+
 	async listOutbound(_addressId?: string): Promise<EmailOutbound[]> {
 		throw new LocalEmailNotAvailableError();
 	}
@@ -72,4 +78,8 @@ export class LocalEmailStorage implements EmailService {
 	async getOutbound(_id: string): Promise<EmailOutbound | null> {
 		throw new LocalEmailNotAvailableError();
 	}
+
+	async deleteOutbound(_id: string): Promise<void> {
+		throw new LocalEmailNotAvailableError();
+	}
 }

package/src/services/local/task.ts

@@ -11,6 +11,19 @@ import type {
 	ListTasksParams,
 	ListTasksResult,
 	TaskChangelogResult,
+	Comment,
+	Tag,
+	ListCommentsResult,
+	ListTagsResult,
+	ListUsersResult,
+	ListProjectsResult,
+	Attachment,
+	CreateAttachmentParams,
+	PresignUploadResponse,
+	PresignDownloadResponse,
+	ListAttachmentsResult,
+	TaskActivityParams,
+	TaskActivityResult,
 } from '@agentuity/core';
 import { StructuredError } from '@agentuity/core';
 import { now } from './_util';
@@ -24,6 +37,46 @@ const TaskNotFoundError = StructuredError('TaskNotFoundError', 'Task not found')
 
 const TaskAlreadyClosedError = StructuredError('TaskAlreadyClosedError', 'Task is already closed');
 
+const CommentNotFoundError = StructuredError('CommentNotFoundError', 'Comment not found');
+
+const TagNotFoundError = StructuredError('TagNotFoundError', 'Tag not found');
+
+const CommentBodyRequiredError = StructuredError(
+	'CommentBodyRequiredError',
+	'Comment body is required and must be a non-empty string'
+);
+
+const CommentUserRequiredError = StructuredError(
+	'CommentUserRequiredError',
+	'Comment user ID is required and must be a non-empty string'
+);
+
+const TagNameRequiredError = StructuredError(
+	'TagNameRequiredError',
+	'Tag name is required and must be a non-empty string'
+);
+
+const AttachmentNotSupportedError = StructuredError(
+	'AttachmentNotSupportedError',
+	'Attachments are not supported in local task storage'
+);
+
+type CommentRow = {
+	id: string;
+	created_at: number;
+	updated_at: number;
+	task_id: string;
+	user_id: string;
+	body: string;
+};
+
+type TagRow = {
+	id: string;
+	created_at: number;
+	name: string;
+	color: string | null;
+};
+
 type TaskRow = {
 	id: string;
 	created_at: number;
@@ -41,6 +94,7 @@ type TaskRow = {
 	created_id: string;
 	assigned_id: string | null;
 	closed_id: string | null;
+	deleted: number;
 };
 
 type TaskChangelogRow = {
@@ -92,9 +146,38 @@ function toTask(row: TaskRow): Task {
 		created_id: row.created_id,
 		assigned_id: row.assigned_id ?? undefined,
 		closed_id: row.closed_id ?? undefined,
+		deleted: Boolean(row.deleted),
 	};
 }
 
+function toComment(row: CommentRow): Comment {
+	return {
+		id: row.id,
+		created_at: new Date(row.created_at).toISOString(),
+		updated_at: new Date(row.updated_at).toISOString(),
+		task_id: row.task_id,
+		user_id: row.user_id,
+		body: row.body,
+	};
+}
+
+function toTag(row: TagRow): Tag {
+	return {
+		id: row.id,
+		created_at: new Date(row.created_at).toISOString(),
+		name: row.name,
+		color: row.color ?? undefined,
+	};
+}
+
+function generateCommentId(): string {
+	return `comment_${crypto.randomUUID().replace(/-/g, '').slice(0, 24)}`;
+}
+
+function generateTagId(): string {
+	return `tag_${crypto.randomUUID().replace(/-/g, '').slice(0, 24)}`;
+}
+
 function toChangelogEntry(row: TaskChangelogRow): TaskChangelogEntry {
 	return {
 		id: row.id,
@@ -168,6 +251,7 @@ export class LocalTaskStorage implements TaskStorage {
 			created_id: params.created_id,
 			assigned_id: params.assigned_id ?? null,
 			closed_id: null,
+			deleted: 0,
 		};
 
 		stmt.run(
@@ -211,7 +295,8 @@ export class LocalTaskStorage implements TaskStorage {
 				closed_date,
 				created_id,
 				assigned_id,
-				closed_id
+				closed_id,
+				deleted
 			FROM task_storage
 			WHERE project_path = ? AND id = ?
 		`);
@@ -278,7 +363,8 @@ export class LocalTaskStorage implements TaskStorage {
 				closed_date,
 				created_id,
 				assigned_id,
-				closed_id
+				closed_id,
+				deleted
 			FROM task_storage
 			${whereClause}
 			ORDER BY ${sortField} ${sortOrder}
@@ -314,7 +400,8 @@ export class LocalTaskStorage implements TaskStorage {
 					closed_date,
 					created_id,
 					assigned_id,
-					closed_id
+					closed_id,
+					deleted
 				FROM task_storage
 				WHERE project_path = ? AND id = ?
 			`);
@@ -493,7 +580,8 @@ export class LocalTaskStorage implements TaskStorage {
 					closed_date,
 					created_id,
 					assigned_id,
-					closed_id
+					closed_id,
+					deleted
 				FROM task_storage
 				WHERE project_path = ? AND id = ?
 			`);
@@ -592,4 +680,360 @@ export class LocalTaskStorage implements TaskStorage {
 			offset,
 		};
 	}
+
+	async softDelete(id: string): Promise<Task> {
+		const task = await this.get(id);
+		if (!task) {
+			throw new TaskNotFoundError();
+		}
+
+		const timestamp = now();
+
+		const updateStmt = this.#db.prepare(`
+			UPDATE task_storage
+			SET status = 'closed', deleted = 1, closed_date = COALESCE(closed_date, ?), updated_at = ?
+			WHERE project_path = ? AND id = ?
+		`);
+
+		updateStmt.run(new Date(timestamp).toISOString(), timestamp, this.#projectPath, id);
+
+		const changelogStmt = this.#db.prepare(`
+			INSERT INTO task_changelog_storage (
+				project_path, id, task_id, field, old_value, new_value, created_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?)
+		`);
+
+		changelogStmt.run(
+			this.#projectPath,
+			generateChangelogId(),
+			id,
+			'deleted',
+			'false',
+			'true',
+			timestamp
+		);
+
+		const updated = await this.get(id);
+		return { ...updated!, deleted: true };
+	}
+
+	async createComment(taskId: string, body: string, userId: string): Promise<Comment> {
+		const trimmedBody = body?.trim();
+		if (!trimmedBody) {
+			throw new CommentBodyRequiredError();
+		}
+
+		const trimmedUserId = userId?.trim();
+		if (!trimmedUserId) {
+			throw new CommentUserRequiredError();
+		}
+
+		const task = await this.get(taskId);
+		if (!task) {
+			throw new TaskNotFoundError();
+		}
+
+		const id = generateCommentId();
+		const timestamp = now();
+
+		const stmt = this.#db.prepare(`
+			INSERT INTO task_comment_storage (
+				project_path, id, task_id, user_id, body, created_at, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?)
+		`);
+
+		stmt.run(this.#projectPath, id, taskId, trimmedUserId, trimmedBody, timestamp, timestamp);
+
+		return toComment({
+			id,
+			created_at: timestamp,
+			updated_at: timestamp,
+			task_id: taskId,
+			user_id: trimmedUserId,
+			body: trimmedBody,
+		});
+	}
+
+	async getComment(commentId: string): Promise<Comment> {
+		const query = this.#db.query(`
+			SELECT id, created_at, updated_at, task_id, user_id, body
+			FROM task_comment_storage
+			WHERE project_path = ? AND id = ?
+		`);
+
+		const row = query.get(this.#projectPath, commentId) as CommentRow | null;
+		if (!row) {
+			throw new CommentNotFoundError();
+		}
+
+		return toComment(row);
+	}
+
+	async updateComment(commentId: string, body: string): Promise<Comment> {
+		const trimmedBody = body?.trim();
+		if (!trimmedBody) {
+			throw new CommentBodyRequiredError();
+		}
+
+		const existing = await this.getComment(commentId);
+		const timestamp = now();
+
+		const stmt = this.#db.prepare(`
+			UPDATE task_comment_storage
+			SET body = ?, updated_at = ?
+			WHERE project_path = ? AND id = ?
+		`);
+
+		stmt.run(trimmedBody, timestamp, this.#projectPath, commentId);
+
+		return {
+			...existing,
+			body: trimmedBody,
+			updated_at: new Date(timestamp).toISOString(),
+		};
+	}
+
+	async deleteComment(commentId: string): Promise<void> {
+		const stmt = this.#db.prepare(`
+			DELETE FROM task_comment_storage
+			WHERE project_path = ? AND id = ?
+		`);
+
+		stmt.run(this.#projectPath, commentId);
+	}
+
+	async listComments(
+		taskId: string,
+		params?: { limit?: number; offset?: number }
+	): Promise<ListCommentsResult> {
+		const limit = params?.limit ?? DEFAULT_LIMIT;
+		const offset = params?.offset ?? 0;
+
+		const totalQuery = this.#db.query(
+			`SELECT COUNT(*) as count FROM task_comment_storage WHERE project_path = ? AND task_id = ?`
+		);
+		const totalRow = totalQuery.get(this.#projectPath, taskId) as { count: number };
+
+		const query = this.#db.query(`
+			SELECT id, created_at, updated_at, task_id, user_id, body
+			FROM task_comment_storage
+			WHERE project_path = ? AND task_id = ?
+			ORDER BY created_at DESC
+			LIMIT ? OFFSET ?
+		`);
+
+		const rows = query.all(this.#projectPath, taskId, limit, offset) as CommentRow[];
+
+		return {
+			comments: rows.map(toComment),
+			total: totalRow.count,
+			limit,
+			offset,
+		};
+	}
+
+	async createTag(name: string, color?: string): Promise<Tag> {
+		const trimmedName = name?.trim();
+		if (!trimmedName) {
+			throw new TagNameRequiredError();
+		}
+
+		const id = generateTagId();
+		const timestamp = now();
+
+		const stmt = this.#db.prepare(`
+			INSERT INTO task_tag_storage (
+				project_path, id, name, color, created_at
+			) VALUES (?, ?, ?, ?, ?)
+		`);
+
+		stmt.run(this.#projectPath, id, trimmedName, color ?? null, timestamp);
+
+		return toTag({
+			id,
+			created_at: timestamp,
+			name: trimmedName,
+			color: color ?? null,
+		});
+	}
+
+	async getTag(tagId: string): Promise<Tag> {
+		const query = this.#db.query(`
+			SELECT id, created_at, name, color
+			FROM task_tag_storage
+			WHERE project_path = ? AND id = ?
+		`);
+
+		const row = query.get(this.#projectPath, tagId) as TagRow | null;
+		if (!row) {
+			throw new TagNotFoundError();
+		}
+
+		return toTag(row);
+	}
+
+	async updateTag(tagId: string, name: string, color?: string): Promise<Tag> {
+		const trimmedName = name?.trim();
+		if (!trimmedName) {
+			throw new TagNameRequiredError();
+		}
+
+		// Verify exists
+		await this.getTag(tagId);
+
+		const stmt = this.#db.prepare(`
+			UPDATE task_tag_storage
+			SET name = ?, color = ?
+			WHERE project_path = ? AND id = ?
+		`);
+
+		stmt.run(trimmedName, color ?? null, this.#projectPath, tagId);
+
+		return this.getTag(tagId);
+	}
+
+	async deleteTag(tagId: string): Promise<void> {
+		// Also remove tag associations
+		const deleteAssocStmt = this.#db.prepare(`
+			DELETE FROM task_tag_association_storage
+			WHERE project_path = ? AND tag_id = ?
+		`);
+		deleteAssocStmt.run(this.#projectPath, tagId);
+
+		const stmt = this.#db.prepare(`
+			DELETE FROM task_tag_storage
+			WHERE project_path = ? AND id = ?
+		`);
+		stmt.run(this.#projectPath, tagId);
+	}
+
+	async listTags(): Promise<ListTagsResult> {
+		const query = this.#db.query(`
+			SELECT id, created_at, name, color
+			FROM task_tag_storage
+			WHERE project_path = ?
+			ORDER BY name ASC
+		`);
+
+		const rows = query.all(this.#projectPath) as TagRow[];
+
+		return {
+			tags: rows.map(toTag),
+		};
+	}
+
+	async addTagToTask(taskId: string, tagId: string): Promise<void> {
+		// Verify task and tag exist
+		const task = await this.get(taskId);
+		if (!task) {
+			throw new TaskNotFoundError();
+		}
+		await this.getTag(tagId);
+
+		const stmt = this.#db.prepare(`
+			INSERT OR IGNORE INTO task_tag_association_storage (
+				project_path, task_id, tag_id
+			) VALUES (?, ?, ?)
+		`);
+
+		stmt.run(this.#projectPath, taskId, tagId);
+	}
+
+	async removeTagFromTask(taskId: string, tagId: string): Promise<void> {
+		const stmt = this.#db.prepare(`
+			DELETE FROM task_tag_association_storage
+			WHERE project_path = ? AND task_id = ? AND tag_id = ?
+		`);
+
+		stmt.run(this.#projectPath, taskId, tagId);
+	}
+
+	async listTagsForTask(taskId: string): Promise<Tag[]> {
+		const query = this.#db.query(`
+			SELECT t.id, t.created_at, t.name, t.color
+			FROM task_tag_storage t
+			INNER JOIN task_tag_association_storage a ON t.id = a.tag_id AND t.project_path = a.project_path
+			WHERE a.project_path = ? AND a.task_id = ?
+			ORDER BY t.name ASC
+		`);
+
+		const rows = query.all(this.#projectPath, taskId) as TagRow[];
+
+		return rows.map(toTag);
+	}
+
+	// Attachment methods — not supported in local storage
+
+	async uploadAttachment(
+		_taskId: string,
+		_params: CreateAttachmentParams
+	): Promise<PresignUploadResponse> {
+		throw new AttachmentNotSupportedError();
+	}
+
+	async confirmAttachment(_attachmentId: string): Promise<Attachment> {
+		throw new AttachmentNotSupportedError();
+	}
+
+	async downloadAttachment(_attachmentId: string): Promise<PresignDownloadResponse> {
+		throw new AttachmentNotSupportedError();
+	}
+
+	async listAttachments(_taskId: string): Promise<ListAttachmentsResult> {
+		throw new AttachmentNotSupportedError();
+	}
+
+	async deleteAttachment(_attachmentId: string): Promise<void> {
+		throw new AttachmentNotSupportedError();
+	}
+
+	async listUsers(): Promise<ListUsersResult> {
+		return { users: [] };
+	}
+
+	async listProjects(): Promise<ListProjectsResult> {
+		return { projects: [] };
+	}
+
+	async getActivity(params?: TaskActivityParams): Promise<TaskActivityResult> {
+		const days = Math.min(365, Math.max(7, params?.days ?? 90));
+		const activity = [];
+		const now = new Date();
+
+		for (let i = days - 1; i >= 0; i--) {
+			const date = new Date(now);
+			date.setDate(date.getDate() - i);
+			const dateStr = date.toISOString().slice(0, 10);
+
+			const row = this.#db
+				.prepare(
+					`SELECT
+						COALESCE(SUM(CASE WHEN status = 'open' THEN 1 ELSE 0 END), 0) as open,
+						COALESCE(SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END), 0) as in_progress,
+						COALESCE(SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END), 0) as done,
+						COALESCE(SUM(CASE WHEN status = 'closed' THEN 1 ELSE 0 END), 0) as closed,
+						COALESCE(SUM(CASE WHEN status = 'cancelled' THEN 1 ELSE 0 END), 0) as cancelled
+					FROM task_storage
+					WHERE project_path = ? AND date(created_at) = ?`
+				)
+				.get(this.#projectPath, dateStr) as {
+				open: number;
+				in_progress: number;
+				done: number;
+				closed: number;
+				cancelled: number;
+			};
+
+			activity.push({
+				date: dateStr,
+				open: row.open,
+				inProgress: row.in_progress,
+				done: row.done,
+				closed: row.closed,
+				cancelled: row.cancelled,
+			});
+		}
+
+		return { activity, days };
+	}
 }