arbiter-skill 0.1.0

package/src/status.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * arbiter status - Check status of a decision plan
+ * 
+ * Usage: arbiter-status <plan-id> [--tag <tag>]
+ * 
+ * Returns JSON with:
+ * - planId: Plan ID
+ * - title: Plan title
+ * - status: pending|in_progress|completed
+ * - total: Total decisions
+ * - answered: Number answered
+ * - remaining: Number remaining
+ * - decisions: Map of decision ID -> { status, answer }
+ */
+
+import type { StatusResult, DecisionStatus } from './types.js';
+import { findPlanFile, parsePlanFile, parseDecisions } from './utils.js';
+
+/**
+ * Get status of a decision plan
+ */
+function status(planId?: string, tag?: string): StatusResult {
+  if (!planId && !tag) {
+    return {
+      planId: '',
+      title: '',
+      status: 'pending',
+      total: 0,
+      answered: 0,
+      remaining: 0,
+      decisions: {},
+      error: 'Either planId or tag is required'
+    };
+  }
+  
+  const file = findPlanFile(planId, tag);
+  if (!file) {
+    return {
+      planId: planId || '',
+      title: '',
+      status: 'pending',
+      total: 0,
+      answered: 0,
+      remaining: 0,
+      decisions: {},
+      error: 'Plan not found'
+    };
+  }
+  
+  const { frontmatter, content } = parsePlanFile(file);
+  const decisions = parseDecisions(content);
+  
+  const decisionMap: Record<string, DecisionStatus> = {};
+  for (const d of decisions) {
+    decisionMap[d.id] = {
+      status: d.status,
+      answer: d.answer
+    };
+  }
+  
+  return {
+    planId: frontmatter.id,
+    title: frontmatter.title,
+    status: frontmatter.status,
+    total: frontmatter.total,
+    answered: frontmatter.answered,
+    remaining: frontmatter.remaining,
+    decisions: decisionMap
+  };
+}
+
+// CLI entry point
+function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(`
+arbiter status - Check status of a decision plan
+
+Usage: arbiter-status <plan-id>
+       arbiter-status --tag <tag>
+
+Example:
+  arbiter-status abc12345
+  arbiter-status --tag nft-marketplace
+`);
+    process.exit(0);
+  }
+  
+  let planId: string | undefined;
+  let tag: string | undefined;
+  
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--tag' && args[i + 1]) {
+      tag = args[i + 1];
+      i++;
+    } else if (!args[i].startsWith('-')) {
+      planId = args[i];
+    }
+  }
+  
+  const result = status(planId, tag);
+  console.log(JSON.stringify(result, null, 2));
+  
+  if (result.error) {
+    process.exit(1);
+  }
+}
+
+main();

package/src/types.ts

@@ -0,0 +1,87 @@
+/**
+ * Type definitions for Arbiter Skill
+ */
+
+export type Priority = 'low' | 'normal' | 'high' | 'urgent';
+export type Status = 'pending' | 'in_progress' | 'completed';
+
+export interface DecisionOption {
+  key: string;
+  label: string;
+  note?: string;
+}
+
+export interface Decision {
+  id: string;
+  title: string;
+  context: string;
+  options: DecisionOption[];
+  allowCustom?: boolean;
+}
+
+export interface PushArgs {
+  title: string;
+  tag?: string;
+  context?: string;
+  priority?: Priority;
+  notify?: string;
+  agent?: string;
+  session?: string;
+  decisions: Decision[];
+}
+
+export interface PushResult {
+  planId: string;
+  file: string;
+  total: number;
+  status: 'pending';
+}
+
+export interface DecisionStatus {
+  status: Status;
+  answer: string | null;
+}
+
+export interface StatusResult {
+  planId: string;
+  title: string;
+  status: Status;
+  total: number;
+  answered: number;
+  remaining: number;
+  decisions: Record<string, DecisionStatus>;
+  error?: string;
+}
+
+export interface GetResult {
+  planId: string;
+  status: 'completed';
+  completedAt: string;
+  answers: Record<string, string>;
+  error?: string;
+}
+
+export interface Frontmatter {
+  id: string;
+  version: number;
+  agent: string;
+  session: string;
+  tag: string;
+  title: string;
+  priority: Priority;
+  status: Status;
+  created_at: string;
+  updated_at: string;
+  completed_at: string | null;
+  total: number;
+  answered: number;
+  remaining: number;
+  notify_session?: string;
+}
+
+export interface ParsedDecision {
+  id: string;
+  status: Status;
+  answer: string | null;
+  answeredAt: string | null;
+}

package/src/utils.ts

@@ -0,0 +1,132 @@
+/**
+ * Utility functions for Arbiter Skill
+ */
+
+import { readdirSync, readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, basename } from 'node:path';
+import matter from 'gray-matter';
+import type { Frontmatter, ParsedDecision, Status } from './types.js';
+
+/**
+ * Get the base arbiter directory
+ */
+export function getArbiterDir(): string {
+  return join(homedir(), '.arbiter');
+}
+
+/**
+ * Get the queue directory
+ */
+export function getQueueDir(subdir: 'pending' | 'completed' | 'notify'): string {
+  return join(getArbiterDir(), 'queue', subdir);
+}
+
+/**
+ * Ensure queue directories exist
+ */
+export function ensureQueueDirs(): void {
+  const dirs = ['pending', 'completed', 'notify'] as const;
+  for (const dir of dirs) {
+    const path = getQueueDir(dir);
+    if (!existsSync(path)) {
+      mkdirSync(path, { recursive: true });
+    }
+  }
+}
+
+/**
+ * Slugify a string for use in filenames
+ */
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 30);
+}
+
+/**
+ * Find a plan file by ID or tag
+ */
+export function findPlanFile(planId?: string, tag?: string): string | null {
+  const dirs = [getQueueDir('pending'), getQueueDir('completed')];
+  
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    
+    const files = readdirSync(dir).filter(f => f.endsWith('.md'));
+    
+    for (const file of files) {
+      const filepath = join(dir, file);
+      
+      // Quick check by filename for planId
+      if (planId && file.includes(planId)) {
+        return filepath;
+      }
+      
+      // Need to read file for tag match
+      if (tag) {
+        try {
+          const content = readFileSync(filepath, 'utf-8');
+          const { data } = matter(content);
+          if (data.tag === tag || data.id === planId) {
+            return filepath;
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Parse a plan file and extract frontmatter
+ */
+export function parsePlanFile(filepath: string): { frontmatter: Frontmatter; content: string } {
+  const raw = readFileSync(filepath, 'utf-8');
+  const { data, content } = matter(raw);
+  return {
+    frontmatter: data as Frontmatter,
+    content
+  };
+}
+
+/**
+ * Parse decision blocks from markdown content
+ */
+export function parseDecisions(content: string): ParsedDecision[] {
+  const decisions: ParsedDecision[] = [];
+  
+  // Split by decision headers (## Decision N: ...)
+  const sections = content.split(/^---$/m);
+  
+  for (const section of sections) {
+    // Look for decision metadata
+    const idMatch = section.match(/^id:\s*(.+)$/m);
+    const statusMatch = section.match(/^status:\s*(.+)$/m);
+    const answerMatch = section.match(/^answer:\s*(.+)$/m);
+    const answeredAtMatch = section.match(/^answered_at:\s*(.+)$/m);
+    
+    if (idMatch) {
+      decisions.push({
+        id: idMatch[1].trim(),
+        status: (statusMatch?.[1]?.trim() || 'pending') as Status,
+        answer: answerMatch?.[1]?.trim() === 'null' ? null : answerMatch?.[1]?.trim() || null,
+        answeredAt: answeredAtMatch?.[1]?.trim() === 'null' ? null : answeredAtMatch?.[1]?.trim() || null
+      });
+    }
+  }
+  
+  return decisions;
+}
+
+/**
+ * Get current ISO timestamp
+ */
+export function nowISO(): string {
+  return new Date().toISOString();
+}

package/templates/decision.md

@@ -0,0 +1,77 @@
+---
+id: {{id}}
+version: 1
+agent: {{agent}}
+session: {{session}}
+tag: {{tag}}
+title: "{{title}}"
+priority: {{priority}}
+status: pending
+created_at: {{created_at}}
+updated_at: {{created_at}}
+completed_at: null
+total: {{total}}
+answered: 0
+remaining: {{total}}
+notify_session: {{notify_session}}
+---
+
+# {{title}}
+
+{{context}}
+
+---
+
+## Decision 1: {{decision_1_title}}
+
+id: {{decision_1_id}}
+status: pending
+answer: null
+answered_at: null
+
+**Context:** {{decision_1_context}}
+
+**Options:**
+- `option1` — Description of option 1
+- `option2` — Description of option 2
+- `option3` — Description of option 3 (optional note)
+
+---
+
+## Decision 2: {{decision_2_title}}
+
+id: {{decision_2_id}}
+status: pending
+answer: null
+answered_at: null
+allow_custom: true
+
+**Context:** {{decision_2_context}}
+
+**Options:**
+- `option1` — Description
+- `option2` — Description
+
+---
+
+<!-- 
+Template variables:
+- {{id}} - Plan ID (auto-generated nanoid)
+- {{agent}} - Agent ID (from CLAWDBOT_AGENT env or argument)
+- {{session}} - Session key (from CLAWDBOT_SESSION env or argument)
+- {{tag}} - Project tag for filtering
+- {{title}} - Plan title
+- {{priority}} - low|normal|high|urgent
+- {{created_at}} - ISO timestamp
+- {{total}} - Number of decisions
+- {{notify_session}} - Session to notify on completion
+
+Each decision:
+- id: Unique within the plan
+- status: pending|answered
+- answer: null or the chosen option key
+- answered_at: null or ISO timestamp
+- allow_custom: true to allow free-text answers
+
+This template is for reference. The actual files are generated by arbiter_push.
+-->

package/tsconfig.json

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