shipsheet 0.0.1 → 0.0.4

package/README.md

@@ -0,0 +1,94 @@
+# shipsheet
+
+CLI for managing a local `tasks.json` ship sheet - exportable to Kanban or Google Sheets.
+
+## Install
+
+```bash
+npm install -g shipsheet
+# or
+npx shipsheet
+```
+
+## Usage
+
+```bash
+# Add tasks
+ss add "Build authentication" -p high -t "feature,backend" --due 2026-02-01
+ss add "Fix login bug" -d "Users can't login with SSO" -p critical
+
+# List tasks
+ss list                    # All tasks
+ss ls -s in-progress       # Filter by status
+ss ls -p high              # Filter by priority
+ss ls -t feature           # Filter by tag
+
+# Manage tasks
+ss show <id>               # Show task details
+ss update <id> -t "New title" -p medium
+ss move <id> in-progress   # Move to status
+ss done <id>               # Mark as done
+ss rm <id>                 # Remove task
+
+# Export
+ss export                  # JSON (default)
+ss export -f csv           # CSV for spreadsheets
+ss export -f kanban        # Kanban board format
+ss export -f sheets        # Google Sheets array format
+ss export -f markdown      # Markdown format
+ss export -f csv -o tasks.csv  # Save to file
+```
+
+## Task Structure
+
+```json
+{
+  "id": "mkwbbi25gbew2",
+  "title": "Build authentication",
+  "description": "Optional description",
+  "status": "todo",
+  "priority": "high",
+  "tags": ["feature", "backend"],
+  "dueDate": "2026-02-01",
+  "createdAt": "2026-01-27T08:00:00.000Z",
+  "updatedAt": "2026-01-27T08:00:00.000Z"
+}
+```
+
+## Statuses
+
+- `todo` - Not started
+- `in-progress` - Currently working
+- `done` - Completed
+- `blocked` - Blocked by something
+
+## Priorities
+
+- `critical` - 🔴 Drop everything
+- `high` - 🟠 Important
+- `medium` - 🟡 Normal (default)
+- `low` - 🟢 When time permits
+
+## Export Formats
+
+| Format | Use Case |
+|--------|----------|
+| `json` | Full data backup, API integration |
+| `csv` | Google Sheets, Excel import |
+| `kanban` | Kanban board tools (Trello, Notion) |
+| `sheets` | Google Sheets API (2D array) |
+| `markdown` | Documentation, GitHub issues |
+
+## AI Skills
+
+Add shipsheet as a skill for AI coding agents:
+
+```bash
+npx skills ahmadawais/shipsheet
+```
+
+This teaches AI agents how to use shipsheet commands in your projects.
+
+## License
+
+MIT

package/dist/export.d.ts

@@ -0,0 +1,6 @@
+import type { Task } from './types.js';
+export declare function toCSV(): string;
+export declare function toKanban(): Record<string, Task[]>;
+export declare function toGoogleSheetsFormat(): string[][];
+export declare function toJSON(): string;
+export declare function toMarkdown(): string;

package/dist/export.js

@@ -0,0 +1,69 @@
+import { loadSheet } from './store.js';
+export function toCSV() {
+    const sheet = loadSheet();
+    const headers = ['ID', 'Title', 'Description', 'Status', 'Priority', 'Tags', 'Due Date', 'Created', 'Updated'];
+    const rows = sheet.tasks.map((t) => [
+        t.id,
+        `"${t.title.replace(/"/g, '""')}"`,
+        `"${(t.description || '').replace(/"/g, '""')}"`,
+        t.status,
+        t.priority,
+        `"${(t.tags || []).join(', ')}"`,
+        t.dueDate || '',
+        t.createdAt,
+        t.updatedAt,
+    ]);
+    return [headers.join(','), ...rows.map((r) => r.join(','))].join('\n');
+}
+export function toKanban() {
+    const sheet = loadSheet();
+    return {
+        todo: sheet.tasks.filter((t) => t.status === 'todo'),
+        'in-progress': sheet.tasks.filter((t) => t.status === 'in-progress'),
+        done: sheet.tasks.filter((t) => t.status === 'done'),
+        blocked: sheet.tasks.filter((t) => t.status === 'blocked'),
+    };
+}
+export function toGoogleSheetsFormat() {
+    const sheet = loadSheet();
+    const headers = ['ID', 'Title', 'Description', 'Status', 'Priority', 'Tags', 'Due Date', 'Created', 'Updated'];
+    const rows = sheet.tasks.map((t) => [
+        t.id,
+        t.title,
+        t.description || '',
+        t.status,
+        t.priority,
+        (t.tags || []).join(', '),
+        t.dueDate || '',
+        t.createdAt,
+        t.updatedAt,
+    ]);
+    return [headers, ...rows];
+}
+export function toJSON() {
+    const sheet = loadSheet();
+    return JSON.stringify(sheet, null, 2);
+}
+export function toMarkdown() {
+    const kanban = toKanban();
+    let md = '# Ship Sheet\n\n';
+    for (const [status, tasks] of Object.entries(kanban)) {
+        md += `## ${status.charAt(0).toUpperCase() + status.slice(1)}\n\n`;
+        if (tasks.length === 0) {
+            md += '_No tasks_\n\n';
+        }
+        else {
+            for (const task of tasks) {
+                const priority = task.priority === 'critical' ? '🔴' : task.priority === 'high' ? '🟠' : task.priority === 'medium' ? '🟡' : '🟢';
+                md += `- ${priority} **${task.title}**`;
+                if (task.description)
+                    md += ` - ${task.description}`;
+                if (task.dueDate)
+                    md += ` (Due: ${task.dueDate})`;
+                md += '\n';
+            }
+            md += '\n';
+        }
+    }
+    return md;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { writeFileSync } from 'node:fs';
+import { addTask, listTasks, updateTask, removeTask, moveTask, getTask } from './store.js';
+import { toCSV, toKanban, toJSON, toMarkdown, toGoogleSheetsFormat } from './export.js';
+const program = new Command();
+program
+    .name('shipsheet')
+    .description('CLI for managing a local tasks.json ship sheet')
+    .version('1.0.0');
+program
+    .command('add <title>')
+    .description('Add a new task')
+    .option('-d, --description <desc>', 'Task description')
+    .option('-s, --status <status>', 'Task status (todo, in-progress, done, blocked)', 'todo')
+    .option('-p, --priority <priority>', 'Task priority (low, medium, high, critical)', 'medium')
+    .option('-t, --tags <tags>', 'Comma-separated tags')
+    .option('--due <date>', 'Due date (YYYY-MM-DD)')
+    .action((title, opts) => {
+    const task = addTask(title, {
+        description: opts.description,
+        status: opts.status,
+        priority: opts.priority,
+        tags: opts.tags?.split(',').map((t) => t.trim()),
+        dueDate: opts.due,
+    });
+    console.log(`✓ Added task: ${task.title} [${task.id}]`);
+});
+program
+    .command('list')
+    .alias('ls')
+    .description('List all tasks')
+    .option('-s, --status <status>', 'Filter by status')
+    .option('-p, --priority <priority>', 'Filter by priority')
+    .option('-t, --tag <tag>', 'Filter by tag')
+    .action((opts) => {
+    const tasks = listTasks({
+        status: opts.status,
+        priority: opts.priority,
+        tag: opts.tag,
+    });
+    if (tasks.length === 0) {
+        console.log('No tasks found.');
+        return;
+    }
+    const statusIcon = {
+        todo: '○',
+        'in-progress': '◐',
+        done: '●',
+        blocked: '✕',
+    };
+    const priorityColor = {
+        critical: '\x1b[31m',
+        high: '\x1b[33m',
+        medium: '\x1b[36m',
+        low: '\x1b[90m',
+    };
+    const reset = '\x1b[0m';
+    for (const task of tasks) {
+        const icon = statusIcon[task.status];
+        const color = priorityColor[task.priority];
+        const tags = task.tags?.length ? ` [${task.tags.join(', ')}]` : '';
+        const due = task.dueDate ? ` (due: ${task.dueDate})` : '';
+        console.log(`${icon} ${color}${task.id.slice(0, 7)}${reset} ${task.title}${tags}${due}`);
+    }
+});
+program
+    .command('show <id>')
+    .description('Show task details')
+    .action((id) => {
+    const task = getTask(id);
+    if (!task) {
+        console.error(`Task not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`ID:          ${task.id}`);
+    console.log(`Title:       ${task.title}`);
+    console.log(`Description: ${task.description || '-'}`);
+    console.log(`Status:      ${task.status}`);
+    console.log(`Priority:    ${task.priority}`);
+    console.log(`Tags:        ${task.tags?.join(', ') || '-'}`);
+    console.log(`Due:         ${task.dueDate || '-'}`);
+    console.log(`Created:     ${task.createdAt}`);
+    console.log(`Updated:     ${task.updatedAt}`);
+});
+program
+    .command('update <id>')
+    .description('Update a task')
+    .option('-t, --title <title>', 'New title')
+    .option('-d, --description <desc>', 'New description')
+    .option('-s, --status <status>', 'New status')
+    .option('-p, --priority <priority>', 'New priority')
+    .option('--tags <tags>', 'New tags (comma-separated)')
+    .option('--due <date>', 'New due date')
+    .action((id, opts) => {
+    const updates = {};
+    if (opts.title)
+        updates.title = opts.title;
+    if (opts.description)
+        updates.description = opts.description;
+    if (opts.status)
+        updates.status = opts.status;
+    if (opts.priority)
+        updates.priority = opts.priority;
+    if (opts.tags)
+        updates.tags = opts.tags.split(',').map((t) => t.trim());
+    if (opts.due)
+        updates.dueDate = opts.due;
+    const task = updateTask(id, updates);
+    if (!task) {
+        console.error(`Task not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`✓ Updated task: ${task.title}`);
+});
+program
+    .command('remove <id>')
+    .alias('rm')
+    .description('Remove a task')
+    .action((id) => {
+    const removed = removeTask(id);
+    if (!removed) {
+        console.error(`Task not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`✓ Removed task`);
+});
+program
+    .command('move <id> <status>')
+    .description('Move task to a status (todo, in-progress, done, blocked)')
+    .action((id, status) => {
+    const validStatuses = ['todo', 'in-progress', 'done', 'blocked'];
+    if (!validStatuses.includes(status)) {
+        console.error(`Invalid status. Use: ${validStatuses.join(', ')}`);
+        process.exit(1);
+    }
+    const task = moveTask(id, status);
+    if (!task) {
+        console.error(`Task not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`✓ Moved "${task.title}" to ${status}`);
+});
+program
+    .command('done <id>')
+    .description('Mark task as done')
+    .action((id) => {
+    const task = moveTask(id, 'done');
+    if (!task) {
+        console.error(`Task not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`✓ Completed: ${task.title}`);
+});
+program
+    .command('export')
+    .description('Export tasks to various formats')
+    .option('-f, --format <format>', 'Export format (csv, json, kanban, markdown, sheets)', 'json')
+    .option('-o, --output <file>', 'Output file (prints to stdout if not specified)')
+    .action((opts) => {
+    let output;
+    switch (opts.format) {
+        case 'csv':
+            output = toCSV();
+            break;
+        case 'kanban':
+            output = JSON.stringify(toKanban(), null, 2);
+            break;
+        case 'markdown':
+        case 'md':
+            output = toMarkdown();
+            break;
+        case 'sheets':
+            output = JSON.stringify(toGoogleSheetsFormat(), null, 2);
+            break;
+        case 'json':
+        default:
+            output = toJSON();
+    }
+    if (opts.output) {
+        writeFileSync(opts.output, output);
+        console.log(`✓ Exported to ${opts.output}`);
+    }
+    else {
+        console.log(output);
+    }
+});
+program.parse();

package/dist/store.d.ts

@@ -0,0 +1,20 @@
+import type { ShipSheet, Task, TaskStatus, TaskPriority } from './types.js';
+export declare function loadSheet(): ShipSheet;
+export declare function saveSheet(sheet: ShipSheet): void;
+export declare function generateId(): string;
+export declare function addTask(title: string, options?: {
+    description?: string;
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    tags?: string[];
+    dueDate?: string;
+}): Task;
+export declare function listTasks(filter?: {
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    tag?: string;
+}): Task[];
+export declare function getTask(id: string): Task | undefined;
+export declare function updateTask(id: string, updates: Partial<Omit<Task, 'id' | 'createdAt'>>): Task | null;
+export declare function removeTask(id: string): boolean;
+export declare function moveTask(id: string, status: TaskStatus): Task | null;

package/dist/store.js

@@ -0,0 +1,93 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+const TASKS_FILE = 'tasks.json';
+function getTasksPath() {
+    return join(process.cwd(), TASKS_FILE);
+}
+function createDefaultSheet() {
+    return {
+        name: 'Ship Sheet',
+        version: '1.0.0',
+        tasks: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+}
+export function loadSheet() {
+    const path = getTasksPath();
+    if (!existsSync(path)) {
+        const sheet = createDefaultSheet();
+        saveSheet(sheet);
+        return sheet;
+    }
+    const data = readFileSync(path, 'utf-8');
+    return JSON.parse(data);
+}
+export function saveSheet(sheet) {
+    sheet.updatedAt = new Date().toISOString();
+    writeFileSync(getTasksPath(), JSON.stringify(sheet, null, 2));
+}
+export function generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
+}
+export function addTask(title, options = {}) {
+    const sheet = loadSheet();
+    const now = new Date().toISOString();
+    const task = {
+        id: generateId(),
+        title,
+        description: options.description,
+        status: options.status || 'todo',
+        priority: options.priority || 'medium',
+        tags: options.tags,
+        createdAt: now,
+        updatedAt: now,
+        dueDate: options.dueDate,
+    };
+    sheet.tasks.push(task);
+    saveSheet(sheet);
+    return task;
+}
+export function listTasks(filter) {
+    const sheet = loadSheet();
+    let tasks = sheet.tasks;
+    if (filter?.status) {
+        tasks = tasks.filter((t) => t.status === filter.status);
+    }
+    if (filter?.priority) {
+        tasks = tasks.filter((t) => t.priority === filter.priority);
+    }
+    if (filter?.tag) {
+        tasks = tasks.filter((t) => t.tags?.includes(filter.tag));
+    }
+    return tasks;
+}
+export function getTask(id) {
+    const sheet = loadSheet();
+    return sheet.tasks.find((t) => t.id === id || t.id.startsWith(id));
+}
+export function updateTask(id, updates) {
+    const sheet = loadSheet();
+    const index = sheet.tasks.findIndex((t) => t.id === id || t.id.startsWith(id));
+    if (index === -1)
+        return null;
+    sheet.tasks[index] = {
+        ...sheet.tasks[index],
+        ...updates,
+        updatedAt: new Date().toISOString(),
+    };
+    saveSheet(sheet);
+    return sheet.tasks[index];
+}
+export function removeTask(id) {
+    const sheet = loadSheet();
+    const index = sheet.tasks.findIndex((t) => t.id === id || t.id.startsWith(id));
+    if (index === -1)
+        return false;
+    sheet.tasks.splice(index, 1);
+    saveSheet(sheet);
+    return true;
+}
+export function moveTask(id, status) {
+    return updateTask(id, { status });
+}

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export type TaskStatus = 'todo' | 'in-progress' | 'done' | 'blocked';
+export type TaskPriority = 'low' | 'medium' | 'high' | 'critical';
+export interface Task {
+    id: string;
+    title: string;
+    description?: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    tags?: string[];
+    createdAt: string;
+    updatedAt: string;
+    dueDate?: string;
+}
+export interface ShipSheet {
+    name: string;
+    version: string;
+    tasks: Task[];
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shipsheet",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "CLI for managing a local tasks.json ship sheet - exportable to Kanban or Google Sheets",
   "type": "module",
   "main": "dist/index.js",
@@ -8,19 +8,40 @@
     "shipsheet": "dist/index.js",
     "ss": "dist/index.js"
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js",
-    "typecheck": "tsc --noEmit"
-  },
-  "keywords": ["cli", "tasks", "todo", "kanban", "shipsheet"],
+  "keywords": [
+    "cli",
+    "tasks",
+    "todo",
+    "kanban",
+    "shipsheet",
+    "skills"
+  ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ahmadawais/shipsheet.git"
+  },
+  "author": "Ahmad Awais",
+  "files": [
+    "dist",
+    "skill"
+  ],
   "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
     "@types/node": "^20.10.0",
     "typescript": "^5.3.0"
   },
   "dependencies": {
     "commander": "^12.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm build && changeset publish && git push --follow-tags && gh release create v$(node -p \"require('./package.json').version\") --generate-notes"
   }
-}
+}

package/skill/SKILL.md

@@ -0,0 +1,74 @@
+# ShipSheet Skill
+
+Manage local task lists with shipsheet CLI. Use when asked to track tasks, create todo lists, or manage a ship sheet.
+
+## When to Use
+
+- User wants to track tasks or todos locally
+- User needs a ship sheet for project management
+- User wants to export tasks to Kanban or Google Sheets
+- User asks to "add a task", "list tasks", "mark done", etc.
+
+## Commands
+
+### Add Task
+```bash
+npx shipsheet add "Task title" -p <priority> -t "tag1,tag2" -d "description" --due YYYY-MM-DD
+```
+
+Options:
+- `-p, --priority`: low, medium, high, critical
+- `-t, --tags`: Comma-separated tags
+- `-d, --description`: Task description
+- `--due`: Due date
+
+### List Tasks
+```bash
+npx shipsheet list
+npx shipsheet ls -s <status> -p <priority> -t <tag>
+```
+
+### Update Task
+```bash
+npx shipsheet update <id> -t "New title" -s <status> -p <priority>
+```
+
+### Move Task Status
+```bash
+npx shipsheet move <id> <status>
+npx shipsheet done <id>
+```
+
+Statuses: `todo`, `in-progress`, `done`, `blocked`
+
+### Remove Task
+```bash
+npx shipsheet rm <id>
+```
+
+### Export Tasks
+```bash
+npx shipsheet export -f <format> -o <output-file>
+```
+
+Formats: `json`, `csv`, `kanban`, `markdown`, `sheets`
+
+## Examples
+
+```bash
+# Add high priority task with tags
+npx shipsheet add "Fix auth bug" -p critical -t "bug,auth"
+
+# List only in-progress tasks
+npx shipsheet ls -s in-progress
+
+# Mark task done (use first few chars of ID)
+npx shipsheet done mkwbb
+
+# Export to CSV for Google Sheets
+npx shipsheet export -f csv -o tasks.csv
+```
+
+## File Location
+
+Tasks are stored in `tasks.json` in the current directory.

package/skill/spec.md

@@ -0,0 +1,90 @@
+# ShipSheet Specification
+
+## Overview
+
+ShipSheet is a CLI tool for managing local task lists stored in `tasks.json`. It provides a simple interface for task management with export capabilities for Kanban boards and Google Sheets.
+
+## Data Model
+
+### ShipSheet (Root)
+```typescript
+interface ShipSheet {
+  name: string;           // Sheet name
+  version: string;        // Schema version
+  tasks: Task[];          // Array of tasks
+  createdAt: string;      // ISO timestamp
+  updatedAt: string;      // ISO timestamp
+}
+```
+
+### Task
+```typescript
+interface Task {
+  id: string;             // Unique identifier (base36 timestamp + random)
+  title: string;          // Task title (required)
+  description?: string;   // Optional description
+  status: TaskStatus;     // Current status
+  priority: TaskPriority; // Priority level
+  tags?: string[];        // Optional tags array
+  dueDate?: string;       // Optional due date (YYYY-MM-DD)
+  createdAt: string;      // ISO timestamp
+  updatedAt: string;      // ISO timestamp
+}
+
+type TaskStatus = 'todo' | 'in-progress' | 'done' | 'blocked';
+type TaskPriority = 'low' | 'medium' | 'high' | 'critical';
+```
+
+## CLI Commands
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `add <title>` | - | Add new task |
+| `list` | `ls` | List all tasks |
+| `show <id>` | - | Show task details |
+| `update <id>` | - | Update task properties |
+| `move <id> <status>` | - | Change task status |
+| `done <id>` | - | Mark task as done |
+| `remove <id>` | `rm` | Delete task |
+| `export` | - | Export to various formats |
+
+## Export Formats
+
+### JSON
+Full `tasks.json` content with all metadata.
+
+### CSV
+```
+ID,Title,Description,Status,Priority,Tags,Due Date,Created,Updated
+```
+
+### Kanban
+```json
+{
+  "todo": [...],
+  "in-progress": [...],
+  "done": [...],
+  "blocked": [...]
+}
+```
+
+### Google Sheets (2D Array)
+```json
+[
+  ["ID", "Title", "Description", "Status", "Priority", "Tags", "Due Date", "Created", "Updated"],
+  ["id1", "Task 1", "", "todo", "high", "tag1, tag2", "", "2026-01-27", "2026-01-27"]
+]
+```
+
+### Markdown
+Kanban-style markdown with priority indicators and grouped by status.
+
+## ID Matching
+
+Task IDs support partial matching - you can use the first few characters of an ID to reference a task (e.g., `mkwbb` instead of `mkwbbi25gbew2`).
+
+## File Storage
+
+- Location: `./tasks.json` in current working directory
+- Format: Pretty-printed JSON (2-space indent)
+- Auto-created on first task add

package/.commandcode/taste/cli/taste.md

@@ -1,22 +0,0 @@
-# Cli
-- Use pnpm as the package manager for CLI projects. Confidence: 1.00
-- Use TypeScript for CLI projects. Confidence: 0.95
-- Use tsup as the build tool for CLI projects. Confidence: 0.95
-- Use vitest for testing CLI projects. Confidence: 0.95
-- Use Commander.js for CLI command handling. Confidence: 0.95
-- Use clack for interactive user input in CLI projects. Confidence: 0.95
-- Check for existing CLI name conflicts before running npm link. Confidence: 0.95
-- Organize CLI commands in a dedicated commands folder with each module separated. Confidence: 0.95
-- Include a small 150px ASCII art welcome banner displaying the CLI name. Confidence: 0.95
-- Use lowercase flags for version and help commands (-v, --version, -h, --help). Confidence: 0.85
-- Start projects with version 0.0.1 instead of 1.0.0. Confidence: 0.85
-- Version command should output only the version number with no ASCII art, banner, or additional information. Confidence: 0.90
-- Read CLI version from package.json instead of hardcoding it in the source code. Confidence: 0.75
-- Always use ora for loading spinners in CLI projects. Confidence: 0.95
-- Use picocolors for terminal string coloring in CLI projects. Confidence: 0.90
-- Use Ink for building interactive CLI UIs in CommandCode projects. Confidence: 0.80
-- Use ink-spinner for loading animations in Ink-based CLIs. Confidence: 0.70
-- Hide internal flags from help: .addOption(new Option('--local').hideHelp()). Confidence: 0.90
-- Use pnpm.onlyBuiltDependencies in package.json to pre-approve native binary builds. Confidence: 0.60
-- Use ANSI Shadow font for ASCII art at large terminal widths and ANSI Compact for small widths. Confidence: 0.85
-- Use minimal white, gray, and black colors for ASCII art banners. Confidence: 0.85

package/.commandcode/taste/taste.md

@@ -1,4 +0,0 @@
-# Taste (Continuously Learned by CommandCode.ai)
-
-# cli
-See [cli/taste.md](cli/taste.md)

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "declaration": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}