open-index/open-npm huggingface dataset:
npm package: @opentask/taskin
Description: Task management system integrated with Git workflows (alias for taskin)
Author: OpenTask
Latest version: 3.0.3

# @opentask/taskin

> Alias package for [taskin](https://www.npmjs.com/package/taskin)

This is a convenience package that installs and re-exports the main `taskin` CLI.

## Installation

```bash
npm install -g @opentask/taskin
```

## Usage

After installation, you can use either command:

```bash
taskin --help
# or
opentask --help
```

## Why this package?

This package exists as a scoped version of the main `taskin` package under the `@opentask` namespace. It's useful for:

- Organizations that prefer scoped packages
- Projects that want to use the `@opentask` namespace
- Easier discovery through the OpenTask organization

## Documentation

For complete documentation, see the main [taskin package](https://www.npmjs.com/package/taskin).

## License

MIT © [OpenTask](https://opentask.com.br)
npm package: @opentask/taskin-design-vue
Description: Vue 3 design system components for Taskin - including the official mascot and UI elements
Latest version: 0.1.1

# @opentask/taskin-design-vue

> Vue 3 design system components for Taskin - including the official mascot and UI elements

## 📦 Installation

```bash
npm install @opentask/taskin-design-vue
# or
pnpm add @opentask/taskin-design-vue
```

## 🚀 Quick Start

### Using the Taskin Mascot

```vue
<script setup lang="ts">
import { TaskinMascot } from '@opentask/taskin-design-vue';
import '@opentask/taskin-design-vue/style.css';
import { ref } from 'vue';

const taskinRef = ref();

const handleReady = (payload) => {
  console.log('Taskin is ready!', payload);

  // Use the controller to interact with the mascot
  payload.controller.celebrate();
};

const celebrate = () => {
  taskinRef.value?.celebrate();
};
</script>

<template>
  <div>
    <TaskinMascot
      ref="taskinRef"
      :size="220"
      mood="sarcastic"
      :idle-animation="true"
      :animations-enabled="true"
      @ready="handleReady"
    />
    <button @click="celebrate">Celebrate!</button>
  </div>
</template>
```

## 🎭 Components

### TaskinMascot

The official Taskin mascot component with animations and moods.

#### Props

- `size` (Number, default: 220) - Size of the mascot in pixels
- `mood` (String, default: 'sarcastic') - Mood of the mascot
- `idleAnimation` (Boolean, default: true) - Enable idle animations
- `animationsEnabled` (Boolean, default: true) - Enable all animations

#### Events

- `@ready` - Emitted when the mascot is ready, provides controller instance

#### Controller Methods

- `celebrate()` - Play celebration animation
- `wave()` - Play wave animation
- `thinking()` - Show thinking animation
- `sleep()` - Put mascot to sleep
- `wakeUp()` - Wake up mascot

## 🎨 Development

### Storybook

```bash
pnpm storybook
```

### Build

```bash
pnpm build
```

### Test

```bash
pnpm test
```

## 📝 License

MIT

## 🔗 Related Packages

- [@opentask/taskin-dashboard](../dashboard) - Dashboard components
- [@opentask/taskin-core](../core) - Core task management
npm package: @opentask/taskin-file-system-provider
Description: File system task provider for Taskin
Author: OpenTask
Latest version: 3.0.2

# @opentask/taskin-file-system-provider

This package provides a file-system-based implementation of the `ITaskProvider` interface from `@opentask/taskin-task-manager`. It interacts with markdown files in the `TASKS` directory.
npm package: @opentask/taskin-task-manager
Description: Task lifecycle management for Taskin
Latest version: 2.0.1

# Task Manager — Metrics Interface

This document describes the new `IMetricsManager` interface introduced to
separate metrics/analytics responsibilities from the core `ITaskProvider`.

## Motivation

Previously the `ITaskProvider` exposed optional methods for statistics
(`getUserStats`, `getTeamStats`, `getTaskStats`). To keep provider
implementations focused on storage concerns and to provide a clearer
contract for analytics, we introduced `IMetricsManager` as a dedicated
interface for metrics/analytics.

## Interface

The interface lives at `packages/task-manager/src/metrics.types.ts`:

- `getUserMetrics(userId: string, query?: StatsQuery): Promise<UserStats>`
- `getTeamMetrics(teamId: string, query?: StatsQuery): Promise<TeamStats>`
- `getTaskMetrics(taskId: string, query?: StatsQuery): Promise<TaskStats>`

Types are re-used from `@opentask/taskin-types` (`UserStats`, `TeamStats`,
`TaskStats`, `StatsQuery`).

## Migration guide

1. Remove any optional stats methods from provider implementations. The
   methods were removed from `ITaskProvider` to avoid mixing concerns.
2. Implement an adapter/service that implements `IMetricsManager` and
   register it alongside your provider (for example, provide it to the
   application bootstrap or dependency injection container).
3. If you need to preserve backward compatibility, expose a thin adapter
   that translates the old provider-level methods to the new
   `IMetricsManager` API until consumers migrate.

## Example

Minimal example of an in-process metrics adapter (pseudo-code):

```ts
import type { IMetricsManager } from '@opentask/taskin-task-manager';
import type { UserStats, StatsQuery } from '@opentask/taskin-types';

export class FsMetricsAdapter implements IMetricsManager {
  constructor(private fsProvider: any) {}

  async getUserMetrics(userId: string, query?: StatsQuery): Promise<UserStats> {
    // Aggregate tasks from fsProvider and compute simple metrics
    const tasks = await this.fsProvider.getAllTasks();
    const userTasks = tasks.filter((t) => t.assignee?.id === userId);
    return { userId, taskCount: userTasks.length } as any;
  }

  // getTeamMetrics / getTaskMetrics implementations...
}
```

## Compatibility and Versioning

- This change is a breaking API change for providers: `ITaskProvider`
  no longer contains stats methods. New providers should implement
  `IMetricsManager` instead.
- For consumers, prefer depending on `IMetricsManager` for analytics
  features. If a provider exposes metrics through a different channel,
  adapt it to `IMetricsManager`.

## Tests

There is a small unit test validating the contract at
`packages/task-manager/src/provider-stats.test.ts` (now checks the
`IMetricsManager` shape).

---

If you want, I can:

- Add an example adapter implementation in `file-system-task-provider`.
- Add documentation to the repo-level `docs/` folder and cross-links.

Tell me which and I’ll implement it.

# @taskin/task-manager

This package is responsible for the core logic of managing tasks.
npm package: @opentask/taskin-task-provider-pinia
Description: Pinia store for task management integration with Taskin
Author: OpenTask
Latest version: 2.0.1

# @opentask/taskin-task-provider-pinia

Pinia-based task provider with WebSocket synchronization for real-time task management in Vue applications.

## Features

- ✅ Implements `ITaskProvider` interface
- ✅ Reactive state management with Pinia
- ✅ Real-time synchronization via WebSocket
- ✅ Offline-first with local cache
- ✅ Automatic reconnection
- ✅ TypeScript support

## Installation

```bash
pnpm add @opentask/taskin-task-provider-pinia
```

## Usage

```typescript
import { createApp } from 'vue';
import { createPinia } from 'pinia';
import { usePiniaTaskProvider } from '@opentask/taskin-task-provider-pinia';

const app = createApp(App);
const pinia = createPinia();
app.use(pinia);

// Connect to WebSocket server
const taskStore = usePiniaTaskProvider();
taskStore.connect('ws://localhost:3001');

// Use as ITaskProvider
const tasks = await taskStore.getAllTasks();
```

## API

See [src/index.ts](./src/index.ts) for full API documentation.

## License

MIT © [OpenTask](https://opentask.com.br)
npm package: @opentask/taskin-task-server-mcp
Description: Model Context Protocol (MCP) server for task management integration with LLMs
Author: OpenTask
Latest version: 0.1.9

# @opentask/taskin-mcp

Model Context Protocol (MCP) server for task management integration with LLMs like Claude, GPT-4, and GitHub Copilot.

## Features

- ✅ Full MCP protocol implementation
- ✅ Exposes task operations as MCP tools
- ✅ Task context via MCP resources
- ✅ Task templates via MCP prompts
- ✅ Real-time task updates
- ✅ TypeScript support
- ✅ Auto-discovery in VS Code and Claude Desktop

## Quick Start

### VS Code (GitHub Copilot)

The server will appear automatically in VS Code's MCP server list after installation:

```bash
npm install -g @opentask/taskin-mcp
```

Then in VS Code:

1. Open Command Palette (`Cmd+Shift+P`)
2. Search for "Configure Tools"
3. Find "taskin" in the MCP servers list
4. Enable it

Or add manually to your `settings.json`:

```json
{
  "github.copilot.chat.mcpServers": {
    "taskin": {
      "command": "taskin-mcp-server"
    }
  }
}
```

### Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "taskin": {
      "args": ["-y", "@opentask/taskin-task-server-mcp"],
      "command": "npx"
    }
  }
}
```

## Installation

### Global (Recommended)

```bash
npm install -g @opentask/taskin-mcp
```

### Project-specific

```bash
pnpm add @opentask/taskin-mcp
```

## Programmatic Usage

```typescript
import { createTaskManager } from '@opentask/taskin-task-manager';
import { createTaskMCPServer } from '@opentask/taskin-task-server-mcp';

// Create task manager with your provider
const taskManager = createTaskManager({
  provider: 'fs',
  config: { tasksDirectory: './TASKS' },
});

// Start MCP server
const server = createTaskMCPServer(taskManager, {
  name: 'taskin-server',
  version: '1.0.0',
});

await server.connect({
  transport: 'stdio', // or 'sse'
});

console.log('MCP server running');
```

## MCP Tools

- `list_tasks` - List all tasks with filters
- `get_task` - Get task details
- `start_task` - Start working on a task
- `finish_task` - Mark task as complete
- `pause_task` - Pause task work
- `lint_tasks` - Validate tasks

## MCP Resources

- `task://{taskId}` - Get full task context
- `tasks://status/{status}` - Get tasks by status

## MCP Prompts

- `start-task` - Template for starting a task
- `review-task` - Template for reviewing a task

## License

MIT © [OpenTask](https://opentask.com.br)
npm package: @opentask/taskin-task-server-ws
Description: WebSocket server for real-time task management
Author: OpenTask
Latest version: 0.2.1

# @opentask/taskin-task-server-ws

WebSocket server for real-time task management. Exposes `ITaskManager` operations via WebSocket protocol with automatic broadcasting of changes to all connected clients.

## Features

- ✅ Real-time task synchronization
- ✅ Multiple client support
- ✅ Automatic change broadcasting
- ✅ Connection management
- ✅ Error handling
- ✅ TypeScript support

## Installation

```bash
pnpm add @opentask/taskin-task-server-ws
```

## Usage

```typescript
import { createTaskManager } from '@opentask/taskin-task-manager';
import { createTaskWebSocketServer } from '@opentask/taskin-task-server-ws';

// Create task manager with your provider
const taskManager = createTaskManager({
  provider: 'fs',
  config: { tasksDirectory: './TASKS' },
});

// Start WebSocket server
const server = createTaskWebSocketServer(taskManager, {
  port: 3001,
  host: 'localhost',
});

console.log('WebSocket server running on ws://localhost:3001');
```

## Protocol

See [src/task-server-ws.types.ts](./src/task-server-ws.types.ts) for message protocol documentation.

## License

MIT © [OpenTask](https://opentask.com.br)
npm package: @opentask/taskin-types
Description: TypeScript types and Zod schemas for Taskin
Author: OpenTask
Latest version: 1.1.1

# @taskin/types-ts

This package is the single source of truth for all data models in the Taskin ecosystem.

## Motivation

To ensure type consistency across different parts of the application (TypeScript and Python), we define all schemas here.

## Purpose

This package uses Zod to define schemas, which are then used to generate TypeScript types and JSON schemas. The JSON schemas are consumed by other packages, like `@taskin/types-py`, to generate types for other languages.