@office-ai/aioncli-core 0.30.0 → 0.30.1

package/dist/src/tools/omissionPlaceholderDetector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Detects shorthand omission placeholders such as:
+ * - (rest of methods ...)
+ * - (rest of code ...)
+ * - (unchanged code ...)
+ * - // rest of methods ...
+ *
+ * Returns all placeholders found as normalized tokens.
+ */
+export declare function detectOmissionPlaceholders(text: string): string[];

package/dist/src/tools/omissionPlaceholderDetector.js

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const OMITTED_PREFIXES = new Set([
+    'rest of',
+    'rest of method',
+    'rest of methods',
+    'rest of code',
+    'unchanged code',
+    'unchanged method',
+    'unchanged methods',
+]);
+function isAllDots(str) {
+    if (str.length === 0) {
+        return false;
+    }
+    for (let i = 0; i < str.length; i++) {
+        if (str[i] !== '.') {
+            return false;
+        }
+    }
+    return true;
+}
+function normalizeWhitespace(input) {
+    const segments = [];
+    let current = '';
+    for (const char of input) {
+        if (char === ' ' || char === '\t' || char === '\n' || char === '\r') {
+            if (current.length > 0) {
+                segments.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0) {
+        segments.push(current);
+    }
+    return segments.join(' ');
+}
+function normalizePlaceholder(line) {
+    let text = line.trim();
+    if (!text) {
+        return null;
+    }
+    if (text.startsWith('//')) {
+        text = text.slice(2).trim();
+    }
+    if (text.startsWith('(') && text.endsWith(')')) {
+        text = text.slice(1, -1).trim();
+    }
+    const ellipsisStart = text.indexOf('...');
+    if (ellipsisStart < 0) {
+        return null;
+    }
+    const prefixRaw = text.slice(0, ellipsisStart).trim().toLowerCase();
+    const suffixRaw = text.slice(ellipsisStart + 3).trim();
+    const prefix = normalizeWhitespace(prefixRaw);
+    if (!OMITTED_PREFIXES.has(prefix)) {
+        return null;
+    }
+    if (suffixRaw.length > 0 && !isAllDots(suffixRaw)) {
+        return null;
+    }
+    return `${prefix} ...`;
+}
+/**
+ * Detects shorthand omission placeholders such as:
+ * - (rest of methods ...)
+ * - (rest of code ...)
+ * - (unchanged code ...)
+ * - // rest of methods ...
+ *
+ * Returns all placeholders found as normalized tokens.
+ */
+export function detectOmissionPlaceholders(text) {
+    const lines = text.replaceAll('\r\n', '\n').split('\n');
+    const matches = [];
+    for (const rawLine of lines) {
+        const normalized = normalizePlaceholder(rawLine);
+        if (normalized) {
+            matches.push(normalized);
+        }
+    }
+    return matches;
+}
+//# sourceMappingURL=omissionPlaceholderDetector.js.map

package/dist/src/tools/omissionPlaceholderDetector.js.map

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

package/dist/src/tools/omissionPlaceholderDetector.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/tools/omissionPlaceholderDetector.test.js

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, expect, it } from 'vitest';
+import { detectOmissionPlaceholders } from './omissionPlaceholderDetector.js';
+describe('detectOmissionPlaceholders', () => {
+    it('detects standalone placeholder lines', () => {
+        expect(detectOmissionPlaceholders('(rest of methods ...)')).toEqual([
+            'rest of methods ...',
+        ]);
+        expect(detectOmissionPlaceholders('(rest of code ...)')).toEqual([
+            'rest of code ...',
+        ]);
+        expect(detectOmissionPlaceholders('(unchanged code ...)')).toEqual([
+            'unchanged code ...',
+        ]);
+        expect(detectOmissionPlaceholders('// rest of methods ...')).toEqual([
+            'rest of methods ...',
+        ]);
+    });
+    it('detects case-insensitive placeholders', () => {
+        expect(detectOmissionPlaceholders('(Rest Of Methods ...)')).toEqual([
+            'rest of methods ...',
+        ]);
+    });
+    it('detects multiple placeholder lines in one input', () => {
+        const text = `class Example {
+  run() {}
+  (rest of methods ...)
+  (unchanged code ...)
+}`;
+        expect(detectOmissionPlaceholders(text)).toEqual([
+            'rest of methods ...',
+            'unchanged code ...',
+        ]);
+    });
+    it('does not detect placeholders embedded in normal code', () => {
+        expect(detectOmissionPlaceholders('const note = "(rest of methods ...)";\nconsole.log(note);')).toEqual([]);
+    });
+    it('does not detect omission phrase when inline in a comment', () => {
+        expect(detectOmissionPlaceholders('return value; // rest of methods ...')).toEqual([]);
+    });
+    it('does not detect unrelated ellipsis text', () => {
+        expect(detectOmissionPlaceholders('const message = "loading...";')).toEqual([]);
+    });
+});
+//# sourceMappingURL=omissionPlaceholderDetector.test.js.map

package/dist/src/tools/omissionPlaceholderDetector.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omissionPlaceholderDetector.test.js","sourceRoot":"","sources":["../../../src/tools/omissionPlaceholderDetector.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAE9E,QAAQ,CAAC,4BAA4B,EAAE,GAAG,EAAE;IAC1C,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,CAAC,0BAA0B,CAAC,uBAAuB,CAAC,CAAC,CAAC,OAAO,CAAC;YAClE,qBAAqB;SACtB,CAAC,CAAC;QACH,MAAM,CAAC,0BAA0B,CAAC,oBAAoB,CAAC,CAAC,CAAC,OAAO,CAAC;YAC/D,kBAAkB;SACnB,CAAC,CAAC;QACH,MAAM,CAAC,0BAA0B,CAAC,sBAAsB,CAAC,CAAC,CAAC,OAAO,CAAC;YACjE,oBAAoB;SACrB,CAAC,CAAC;QACH,MAAM,CAAC,0BAA0B,CAAC,wBAAwB,CAAC,CAAC,CAAC,OAAO,CAAC;YACnE,qBAAqB;SACtB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC/C,MAAM,CAAC,0BAA0B,CAAC,uBAAuB,CAAC,CAAC,CAAC,OAAO,CAAC;YAClE,qBAAqB;SACtB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QACzD,MAAM,IAAI,GAAG;;;;EAIf,CAAC;QACC,MAAM,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;YAC/C,qBAAqB;YACrB,oBAAoB;SACrB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;QAC9D,MAAM,CACJ,0BAA0B,CACxB,2DAA2D,CAC5D,CACF,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;QAClE,MAAM,CACJ,0BAA0B,CAAC,sCAAsC,CAAC,CACnE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACjD,MAAM,CAAC,0BAA0B,CAAC,+BAA+B,CAAC,CAAC,CAAC,OAAO,CACzE,EAAE,CACH,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/src/tools/trackerTools.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Config } from '../config/config.js';
+import type { MessageBus } from '../confirmation-bus/message-bus.js';
+import type { ToolResult } from './tools.js';
+import { BaseDeclarativeTool, BaseToolInvocation } from './tools.js';
+import type { TaskType } from '../services/trackerTypes.js';
+import { TaskStatus } from '../services/trackerTypes.js';
+interface CreateTaskParams {
+    title: string;
+    description: string;
+    type: TaskType;
+    parentId?: string;
+    dependencies?: string[];
+}
+declare class TrackerCreateTaskInvocation extends BaseToolInvocation<CreateTaskParams, ToolResult> {
+    private readonly config;
+    constructor(config: Config, params: CreateTaskParams, messageBus: MessageBus, toolName: string);
+    private get service();
+    getDescription(): string;
+    execute(_signal: AbortSignal): Promise<ToolResult>;
+}
+export declare class TrackerCreateTaskTool extends BaseDeclarativeTool<CreateTaskParams, ToolResult> {
+    private config;
+    static readonly Name = "tracker_create_task";
+    constructor(config: Config, messageBus: MessageBus);
+    protected createInvocation(params: CreateTaskParams, messageBus: MessageBus): TrackerCreateTaskInvocation;
+    getSchema(modelId?: string): import("@google/genai").FunctionDeclaration;
+}
+interface UpdateTaskParams {
+    id: string;
+    title?: string;
+    description?: string;
+    status?: TaskStatus;
+    dependencies?: string[];
+}
+declare class TrackerUpdateTaskInvocation extends BaseToolInvocation<UpdateTaskParams, ToolResult> {
+    private readonly config;
+    constructor(config: Config, params: UpdateTaskParams, messageBus: MessageBus, toolName: string);
+    private get service();
+    getDescription(): string;
+    execute(_signal: AbortSignal): Promise<ToolResult>;
+}
+export declare class TrackerUpdateTaskTool extends BaseDeclarativeTool<UpdateTaskParams, ToolResult> {
+    private config;
+    static readonly Name = "tracker_update_task";
+    constructor(config: Config, messageBus: MessageBus);
+    protected createInvocation(params: UpdateTaskParams, messageBus: MessageBus): TrackerUpdateTaskInvocation;
+    getSchema(modelId?: string): import("@google/genai").FunctionDeclaration;
+}
+interface GetTaskParams {
+    id: string;
+}
+declare class TrackerGetTaskInvocation extends BaseToolInvocation<GetTaskParams, ToolResult> {
+    private readonly config;
+    constructor(config: Config, params: GetTaskParams, messageBus: MessageBus, toolName: string);
+    private get service();
+    getDescription(): string;
+    execute(_signal: AbortSignal): Promise<ToolResult>;
+}
+export declare class TrackerGetTaskTool extends BaseDeclarativeTool<GetTaskParams, ToolResult> {
+    private config;
+    static readonly Name = "tracker_get_task";
+    constructor(config: Config, messageBus: MessageBus);
+    protected createInvocation(params: GetTaskParams, messageBus: MessageBus): TrackerGetTaskInvocation;
+    getSchema(modelId?: string): import("@google/genai").FunctionDeclaration;
+}
+interface ListTasksParams {
+    status?: TaskStatus;
+    type?: TaskType;
+    parentId?: string;
+}
+declare class TrackerListTasksInvocation extends BaseToolInvocation<ListTasksParams, ToolResult> {
+    private readonly config;
+    constructor(config: Config, params: ListTasksParams, messageBus: MessageBus, toolName: string);
+    private get service();
+    getDescription(): string;
+    execute(_signal: AbortSignal): Promise<ToolResult>;
+}
+export declare class TrackerListTasksTool extends BaseDeclarativeTool<ListTasksParams, ToolResult> {
+    private config;
+    static readonly Name = "tracker_list_tasks";
+    constructor(config: Config, messageBus: MessageBus);
+    protected createInvocation(params: ListTasksParams, messageBus: MessageBus): TrackerListTasksInvocation;
+    getSchema(modelId?: string): import("@google/genai").FunctionDeclaration;
+}
+interface AddDependencyParams {
+    taskId: string;
+    dependencyId: string;
+}
+declare class TrackerAddDependencyInvocation extends BaseToolInvocation<AddDependencyParams, ToolResult> {
+    private readonly config;
+    constructor(config: Config, params: AddDependencyParams, messageBus: MessageBus, toolName: string);
+    private get service();
+    getDescription(): string;
+    execute(_signal: AbortSignal): Promise<ToolResult>;
+}
+export declare class TrackerAddDependencyTool extends BaseDeclarativeTool<AddDependencyParams, ToolResult> {
+    private config;
+    static readonly Name = "tracker_add_dependency";
+    constructor(config: Config, messageBus: MessageBus);
+    protected createInvocation(params: AddDependencyParams, messageBus: MessageBus): TrackerAddDependencyInvocation;
+    getSchema(modelId?: string): import("@google/genai").FunctionDeclaration;
+}
+declare class TrackerVisualizeInvocation extends BaseToolInvocation<Record<string, never>, ToolResult> {
+    private readonly config;
+    constructor(config: Config, params: Record<string, never>, messageBus: MessageBus, toolName: string);
+    private get service();
+    getDescription(): string;
+    execute(_signal: AbortSignal): Promise<ToolResult>;
+}
+export declare class TrackerVisualizeTool extends BaseDeclarativeTool<Record<string, never>, ToolResult> {
+    private config;
+    static readonly Name = "tracker_visualize";
+    constructor(config: Config, messageBus: MessageBus);
+    protected createInvocation(params: Record<string, never>, messageBus: MessageBus): TrackerVisualizeInvocation;
+    getSchema(modelId?: string): import("@google/genai").FunctionDeclaration;
+}
+export {};

package/dist/src/tools/trackerTools.js

@@ -0,0 +1,365 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TRACKER_ADD_DEPENDENCY_DEFINITION, TRACKER_CREATE_TASK_DEFINITION, TRACKER_GET_TASK_DEFINITION, TRACKER_LIST_TASKS_DEFINITION, TRACKER_UPDATE_TASK_DEFINITION, TRACKER_VISUALIZE_DEFINITION, } from './definitions/trackerTools.js';
+import { resolveToolDeclaration } from './definitions/resolver.js';
+import { TRACKER_ADD_DEPENDENCY_TOOL_NAME, TRACKER_CREATE_TASK_TOOL_NAME, TRACKER_GET_TASK_TOOL_NAME, TRACKER_LIST_TASKS_TOOL_NAME, TRACKER_UPDATE_TASK_TOOL_NAME, TRACKER_VISUALIZE_TOOL_NAME, } from './tool-names.js';
+import { BaseDeclarativeTool, BaseToolInvocation, Kind } from './tools.js';
+import { ToolErrorType } from './tool-error.js';
+import { TaskStatus } from '../services/trackerTypes.js';
+class TrackerCreateTaskInvocation extends BaseToolInvocation {
+    config;
+    constructor(config, params, messageBus, toolName) {
+        super(params, messageBus, toolName);
+        this.config = config;
+    }
+    get service() {
+        return this.config.getTrackerService();
+    }
+    getDescription() {
+        return `Creating task: ${this.params.title}`;
+    }
+    async execute(_signal) {
+        try {
+            const task = await this.service.createTask({
+                title: this.params.title,
+                description: this.params.description,
+                type: this.params.type,
+                status: TaskStatus.OPEN,
+                parentId: this.params.parentId,
+                dependencies: this.params.dependencies ?? [],
+            });
+            return {
+                llmContent: `Created task ${task.id}: ${task.title}`,
+                returnDisplay: `Created task ${task.id}.`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error creating task: ${errorMessage}`,
+                returnDisplay: 'Failed to create task.',
+                error: {
+                    message: errorMessage,
+                    type: ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+export class TrackerCreateTaskTool extends BaseDeclarativeTool {
+    config;
+    static Name = TRACKER_CREATE_TASK_TOOL_NAME;
+    constructor(config, messageBus) {
+        super(TrackerCreateTaskTool.Name, 'Create Task', TRACKER_CREATE_TASK_DEFINITION.base.description, Kind.Edit, TRACKER_CREATE_TASK_DEFINITION.base.parametersJsonSchema, messageBus);
+        this.config = config;
+    }
+    createInvocation(params, messageBus) {
+        return new TrackerCreateTaskInvocation(this.config, params, messageBus, this.name);
+    }
+    getSchema(modelId) {
+        return resolveToolDeclaration(TRACKER_CREATE_TASK_DEFINITION, modelId);
+    }
+}
+class TrackerUpdateTaskInvocation extends BaseToolInvocation {
+    config;
+    constructor(config, params, messageBus, toolName) {
+        super(params, messageBus, toolName);
+        this.config = config;
+    }
+    get service() {
+        return this.config.getTrackerService();
+    }
+    getDescription() {
+        return `Updating task ${this.params.id}`;
+    }
+    async execute(_signal) {
+        const { id, ...updates } = this.params;
+        try {
+            const task = await this.service.updateTask(id, updates);
+            return {
+                llmContent: `Updated task ${task.id}. Status: ${task.status}`,
+                returnDisplay: `Updated task ${task.id}.`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error updating task: ${errorMessage}`,
+                returnDisplay: 'Failed to update task.',
+                error: {
+                    message: errorMessage,
+                    type: ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+export class TrackerUpdateTaskTool extends BaseDeclarativeTool {
+    config;
+    static Name = TRACKER_UPDATE_TASK_TOOL_NAME;
+    constructor(config, messageBus) {
+        super(TrackerUpdateTaskTool.Name, 'Update Task', TRACKER_UPDATE_TASK_DEFINITION.base.description, Kind.Edit, TRACKER_UPDATE_TASK_DEFINITION.base.parametersJsonSchema, messageBus);
+        this.config = config;
+    }
+    createInvocation(params, messageBus) {
+        return new TrackerUpdateTaskInvocation(this.config, params, messageBus, this.name);
+    }
+    getSchema(modelId) {
+        return resolveToolDeclaration(TRACKER_UPDATE_TASK_DEFINITION, modelId);
+    }
+}
+class TrackerGetTaskInvocation extends BaseToolInvocation {
+    config;
+    constructor(config, params, messageBus, toolName) {
+        super(params, messageBus, toolName);
+        this.config = config;
+    }
+    get service() {
+        return this.config.getTrackerService();
+    }
+    getDescription() {
+        return `Retrieving task ${this.params.id}`;
+    }
+    async execute(_signal) {
+        const task = await this.service.getTask(this.params.id);
+        if (!task) {
+            return {
+                llmContent: `Task ${this.params.id} not found.`,
+                returnDisplay: 'Task not found.',
+            };
+        }
+        return {
+            llmContent: JSON.stringify(task, null, 2),
+            returnDisplay: `Retrieved task ${task.id}.`,
+        };
+    }
+}
+export class TrackerGetTaskTool extends BaseDeclarativeTool {
+    config;
+    static Name = TRACKER_GET_TASK_TOOL_NAME;
+    constructor(config, messageBus) {
+        super(TrackerGetTaskTool.Name, 'Get Task', TRACKER_GET_TASK_DEFINITION.base.description, Kind.Read, TRACKER_GET_TASK_DEFINITION.base.parametersJsonSchema, messageBus);
+        this.config = config;
+    }
+    createInvocation(params, messageBus) {
+        return new TrackerGetTaskInvocation(this.config, params, messageBus, this.name);
+    }
+    getSchema(modelId) {
+        return resolveToolDeclaration(TRACKER_GET_TASK_DEFINITION, modelId);
+    }
+}
+class TrackerListTasksInvocation extends BaseToolInvocation {
+    config;
+    constructor(config, params, messageBus, toolName) {
+        super(params, messageBus, toolName);
+        this.config = config;
+    }
+    get service() {
+        return this.config.getTrackerService();
+    }
+    getDescription() {
+        return 'Listing tasks.';
+    }
+    async execute(_signal) {
+        let tasks = await this.service.listTasks();
+        if (this.params.status) {
+            tasks = tasks.filter((t) => t.status === this.params.status);
+        }
+        if (this.params.type) {
+            tasks = tasks.filter((t) => t.type === this.params.type);
+        }
+        if (this.params.parentId) {
+            tasks = tasks.filter((t) => t.parentId === this.params.parentId);
+        }
+        if (tasks.length === 0) {
+            return {
+                llmContent: 'No tasks found matching the criteria.',
+                returnDisplay: 'No matching tasks.',
+            };
+        }
+        const content = tasks
+            .map((t) => `- [${t.id}] ${t.title} (${t.status})`)
+            .join('\n');
+        return {
+            llmContent: content,
+            returnDisplay: `Listed ${tasks.length} tasks.`,
+        };
+    }
+}
+export class TrackerListTasksTool extends BaseDeclarativeTool {
+    config;
+    static Name = TRACKER_LIST_TASKS_TOOL_NAME;
+    constructor(config, messageBus) {
+        super(TrackerListTasksTool.Name, 'List Tasks', TRACKER_LIST_TASKS_DEFINITION.base.description, Kind.Search, TRACKER_LIST_TASKS_DEFINITION.base.parametersJsonSchema, messageBus);
+        this.config = config;
+    }
+    createInvocation(params, messageBus) {
+        return new TrackerListTasksInvocation(this.config, params, messageBus, this.name);
+    }
+    getSchema(modelId) {
+        return resolveToolDeclaration(TRACKER_LIST_TASKS_DEFINITION, modelId);
+    }
+}
+class TrackerAddDependencyInvocation extends BaseToolInvocation {
+    config;
+    constructor(config, params, messageBus, toolName) {
+        super(params, messageBus, toolName);
+        this.config = config;
+    }
+    get service() {
+        return this.config.getTrackerService();
+    }
+    getDescription() {
+        return `Adding dependency: ${this.params.taskId} depends on ${this.params.dependencyId}`;
+    }
+    async execute(_signal) {
+        if (this.params.taskId === this.params.dependencyId) {
+            return {
+                llmContent: `Error: Task ${this.params.taskId} cannot depend on itself.`,
+                returnDisplay: 'Self-referential dependency rejected.',
+                error: {
+                    message: 'Task cannot depend on itself',
+                    type: ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+        const [task, dep] = await Promise.all([
+            this.service.getTask(this.params.taskId),
+            this.service.getTask(this.params.dependencyId),
+        ]);
+        if (!task) {
+            return {
+                llmContent: `Task ${this.params.taskId} not found.`,
+                returnDisplay: 'Task not found.',
+            };
+        }
+        if (!dep) {
+            return {
+                llmContent: `Dependency task ${this.params.dependencyId} not found.`,
+                returnDisplay: 'Dependency not found.',
+            };
+        }
+        const newDeps = Array.from(new Set([...task.dependencies, this.params.dependencyId]));
+        try {
+            await this.service.updateTask(task.id, { dependencies: newDeps });
+            return {
+                llmContent: `Linked ${task.id} -> ${dep.id}.`,
+                returnDisplay: 'Dependency added.',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error adding dependency: ${errorMessage}`,
+                returnDisplay: 'Failed to add dependency.',
+                error: {
+                    message: errorMessage,
+                    type: ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+export class TrackerAddDependencyTool extends BaseDeclarativeTool {
+    config;
+    static Name = TRACKER_ADD_DEPENDENCY_TOOL_NAME;
+    constructor(config, messageBus) {
+        super(TrackerAddDependencyTool.Name, 'Add Dependency', TRACKER_ADD_DEPENDENCY_DEFINITION.base.description, Kind.Edit, TRACKER_ADD_DEPENDENCY_DEFINITION.base.parametersJsonSchema, messageBus);
+        this.config = config;
+    }
+    createInvocation(params, messageBus) {
+        return new TrackerAddDependencyInvocation(this.config, params, messageBus, this.name);
+    }
+    getSchema(modelId) {
+        return resolveToolDeclaration(TRACKER_ADD_DEPENDENCY_DEFINITION, modelId);
+    }
+}
+// --- tracker_visualize ---
+class TrackerVisualizeInvocation extends BaseToolInvocation {
+    config;
+    constructor(config, params, messageBus, toolName) {
+        super(params, messageBus, toolName);
+        this.config = config;
+    }
+    get service() {
+        return this.config.getTrackerService();
+    }
+    getDescription() {
+        return 'Visualizing the task graph.';
+    }
+    async execute(_signal) {
+        const tasks = await this.service.listTasks();
+        if (tasks.length === 0) {
+            return {
+                llmContent: 'No tasks to visualize.',
+                returnDisplay: 'Empty tracker.',
+            };
+        }
+        const statusEmojis = {
+            open: '⭕',
+            in_progress: '🚧',
+            blocked: '🚫',
+            closed: '✅',
+        };
+        const typeLabels = {
+            epic: '[EPIC]',
+            task: '[TASK]',
+            bug: '[BUG]',
+        };
+        const childrenMap = new Map();
+        const roots = [];
+        for (const task of tasks) {
+            if (task.parentId) {
+                if (!childrenMap.has(task.parentId)) {
+                    childrenMap.set(task.parentId, []);
+                }
+                childrenMap.get(task.parentId).push(task);
+            }
+            else {
+                roots.push(task);
+            }
+        }
+        let output = 'Task Tracker Graph:\n';
+        const renderTask = (task, depth, visited) => {
+            if (visited.has(task.id)) {
+                output += `${'  '.repeat(depth)}[CYCLE DETECTED: ${task.id}]\n`;
+                return;
+            }
+            visited.add(task.id);
+            const indent = '  '.repeat(depth);
+            output += `${indent}${statusEmojis[task.status]} ${task.id} ${typeLabels[task.type]} ${task.title}\n`;
+            if (task.dependencies.length > 0) {
+                output += `${indent}  └─ Depends on: ${task.dependencies.join(', ')}\n`;
+            }
+            const children = childrenMap.get(task.id) ?? [];
+            for (const child of children) {
+                renderTask(child, depth + 1, new Set(visited));
+            }
+        };
+        for (const root of roots) {
+            renderTask(root, 0, new Set());
+        }
+        return {
+            llmContent: output,
+            returnDisplay: output,
+        };
+    }
+}
+export class TrackerVisualizeTool extends BaseDeclarativeTool {
+    config;
+    static Name = TRACKER_VISUALIZE_TOOL_NAME;
+    constructor(config, messageBus) {
+        super(TrackerVisualizeTool.Name, 'Visualize Tracker', TRACKER_VISUALIZE_DEFINITION.base.description, Kind.Read, TRACKER_VISUALIZE_DEFINITION.base.parametersJsonSchema, messageBus);
+        this.config = config;
+    }
+    createInvocation(params, messageBus) {
+        return new TrackerVisualizeInvocation(this.config, params, messageBus, this.name);
+    }
+    getSchema(modelId) {
+        return resolveToolDeclaration(TRACKER_VISUALIZE_DEFINITION, modelId);
+    }
+}
+//# sourceMappingURL=trackerTools.js.map