pi-anchor 0.2.2 → 0.2.4

package/src/extension.ts

@@ -1,18 +1,88 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { Type } from '@sinclair/typebox';
-import { AnchorStore } from './store.ts';
+import { AnchorStore, detectTargetDate } from './store.ts';
 import { SessionTouchObserver } from './observer.ts';
 import { renderColdStartAnchorsContext, renderActiveAnchorsContext, makeSafeTaskAnnotation } from './context_injector.ts';
 import { generateSettlementProposals, runPhysicalVerification } from './settlement.ts';
 import { normalizePath, isSameOrSubPath, findMatchedAnchors } from './matcher.ts';
 import { sweepStore } from './decay.ts';
-import { updateAnchorStatusBar, openAnchorDashboard, updateStartupBanner, truncateToWidth, hasActiveUI } from './tui.ts';
+import { updateAnchorStatusBar, openAnchorDashboard, updateStartupBanner, truncateToWidth, hasActiveUI, groupAnchorsByQuadrant } from './tui.ts';
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
 const MUTATION_TOOLS = new Set(['edit', 'write', 'patch', 'apply_diff', 'create_file', 'modify']);
 
+/**
+ * Parse inline `--due <date>` / `-d <date>` flags and `done`/`rm`/`close`/`settle` subcommands
+ * for `/anchor` and `/pin` slash commands.
+ */
+export function parseAnchorCommandInput(raw: string, now: number = Date.now()): {
+  mode: 'dashboard' | 'undo' | 'settle' | 'pin';
+  targetId?: string;
+  title?: string;
+  targetDate?: string;
+} {
+  const trimmed = (raw || '').trim();
+  if (!trimmed || trimmed === 'list' || trimmed === 'ls') {
+    return { mode: 'dashboard' };
+  }
+  if (trimmed === 'undo') {
+    return { mode: 'undo' };
+  }
+
+  // Match explicit settle subcommands: `/anchor done 1`, `/anchor rm anc-2`, `/anchor settle #1`
+  const settleMatch = trimmed.match(/^(?:done|rm|close|settle)\s+(.+)$/i);
+  if (settleMatch) {
+    return {
+      mode: 'settle',
+      targetId: settleMatch[1].trim().replace(/^#/, '')
+    };
+  }
+
+  // Extract optional `--due <val>` or `-d <val>` flag
+  let targetDate: string | undefined;
+  const tokens = trimmed.split(/\s+/);
+  const dueIdx = tokens.findIndex(t => t === '--due' || t === '-d');
+  if (dueIdx !== -1 && tokens[dueIdx + 1]) {
+    const rawDue = tokens[dueIdx + 1];
+    targetDate = detectTargetDate(rawDue, now) || rawDue;
+    tokens.splice(dueIdx, 2);
+  }
+  const cleanTitle = tokens.join(' ').trim();
+
+  return {
+    mode: 'pin',
+    title: cleanTitle || trimmed,
+    targetDate
+  };
+}
+
+/**
+ * Resolve either an explicit anchor ID ('anc-2', '2') or a 1-based visual dashboard index ('01', '1')
+ */
+export function resolveAnchorTarget(store: AnchorStore, idOrIndex: string, cwd?: string): string | undefined {
+  const clean = idOrIndex.trim().replace(/^#/, '');
+  // 1. Check 1-based sequential index from the active quadrant-sorted list first when user passes a plain number
+  if (/^\d+$/.test(clean)) {
+    const seqIndex = parseInt(clean, 10);
+    const active = store.list({ status: 'active', cwd });
+    const groups = groupAnchorsByQuadrant(active);
+    const sortedActive = [
+      ...groups.today,
+      ...groups.upcoming,
+      ...groups.habits,
+      ...groups.backlog
+    ];
+    if (seqIndex >= 1 && seqIndex <= sortedActive.length) {
+      return sortedActive[seqIndex - 1].id;
+    }
+  }
+  // 2. Fallback to direct ID lookup in store
+  const direct = store.get(clean);
+  return direct?.id;
+}
+
 export default function (pi: ExtensionAPI) {
   // Global authoritative store in ~/.anchor/ (0 workspace clutter)
   const store = new AnchorStore();
@@ -29,7 +99,7 @@ export default function (pi: ExtensionAPI) {
     const sweep = sweepStore(store);
 
     if (sweep.transitionedToSleeping.length > 0) {
-      ctx.ui.notify(`Anchor: ${sweep.transitionedToSleeping.length} 个非活跃任务已进入休眠`, 'info');
+      ctx.ui.notify(`⌖ Anchor: ${sweep.transitionedToSleeping.length} inactive tasks transitioned to sleep`, 'info');
     }
 
     // Physical Pre-flight Verification: auto-settle passing tasks or record failing output (scoped strictly to current cwd)
@@ -43,7 +113,7 @@ export default function (pi: ExtensionAPI) {
               settledBy: 'verification-test',
               summary: `Physical pre-flight test passed: ${a.verifyCommand}`
             });
-            ctx.ui.notify(`⚓ 物理验证通过！锚点 #${a.id} ("${a.title}") 已自动结案归档。`, 'info');
+            ctx.ui.notify(`⌖ Verification passed! Auto-settled #${a.id}: "${a.title}"`, 'info');
           } else {
             preflightFailures.set(a.id, res.output.slice(-250));
           }
@@ -416,20 +486,20 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // 6. User Slash Commands: /anchor and /pin
+  // 6. User Slash Commands: /anchor, /pin, and /done
   pi.registerCommand('anchor', {
-    description: 'Inspect and settle active anchors',
+    description: 'Inspect, pin, or settle active anchors (e.g. /anchor, /anchor done 1, /anchor undo)',
     handler: async (args: string, ctx: ExtensionContext) => {
-      const input = (args || '').trim();
+      const parsed = parseAnchorCommandInput(args);
 
       // Case 1: View active anchors (clean list, enter to complete)
-      if (!input || input === 'list' || input === 'ls') {
+      if (parsed.mode === 'dashboard') {
         await openAnchorDashboard(ctx, store);
         return;
       }
 
       // Case 2: Revert settlement
-      if (input === 'undo') {
+      if (parsed.mode === 'undo') {
         try {
           const restored = store.undoSettle();
           ctx.ui.notify(`⌖ Restored #${restored.id}: "${restored.title}"`, 'info');
@@ -440,34 +510,77 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      // Case 3: Complete directly by ID (e.g. /anchor anc-1)
-      const targetId = input.startsWith('#') ? input.slice(1) : input;
-      const item = store.get(targetId);
-      if (item) {
-        store.settle(targetId, { settledBy: 'manual-command' });
-        ctx.ui.notify(`⌖ Settled: "${item.title}"`, 'info');
+      // Case 3: Explicit settle subcommand (`/anchor done 1` or `/anchor done anc-1`)
+      if (parsed.mode === 'settle' && parsed.targetId) {
+        const resolvedId = resolveAnchorTarget(store, parsed.targetId, ctx.cwd);
+        if (!resolvedId) {
+          ctx.ui.notify(`⌖ Anchor not found: ${parsed.targetId}`, 'error');
+          return;
+        }
+        const settled = store.settle(resolvedId, { settledBy: 'manual-command' });
+        ctx.ui.notify(`⌖ Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, 'info');
         updateAnchorStatusBar(ctx, store);
         return;
       }
 
-      // Case 4: Freeform text directly creates an anchor
-      const anc = store.create({ title: input, cwd: ctx.cwd });
-      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"`, 'info');
+      // Case 4: Direct ID completion if input matches an existing ID (e.g. `/anchor anc-1` or `/anchor #1`)
+      const rawTrimmed = (args || '').trim();
+      if (/^(?:#?anc-\d+|#\d+)$/i.test(rawTrimmed)) {
+        const resolvedId = resolveAnchorTarget(store, rawTrimmed, ctx.cwd);
+        if (resolvedId) {
+          const settled = store.settle(resolvedId, { settledBy: 'manual-command' });
+          ctx.ui.notify(`⌖ Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, 'info');
+          updateAnchorStatusBar(ctx, store);
+          return;
+        }
+      }
+
+      // Case 5: Freeform text creates an anchor (supports `--due <date>`)
+      const anc = store.create({
+        title: parsed.title || rawTrimmed,
+        targetDate: parsed.targetDate,
+        cwd: ctx.cwd
+      });
+      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ''}`, 'info');
       updateAnchorStatusBar(ctx, store);
     }
   });
 
-  // Alias /pin to instant-add
+  // Alias /pin to instant-add (supports `--due <date>`)
   pi.registerCommand('pin', {
-    description: 'Quickly pin a task across sessions',
+    description: 'Pin a task across sessions (e.g. /pin Refactor auth --due tomorrow)',
     handler: async (args: string, ctx: ExtensionContext) => {
-      const title = (args || '').trim();
-      if (!title) {
+      const parsed = parseAnchorCommandInput(args);
+      if (parsed.mode === 'dashboard' || !parsed.title) {
         await openAnchorDashboard(ctx, store);
         return;
       }
-      const anc = store.create({ title, cwd: ctx.cwd });
-      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"`, 'info');
+      const anc = store.create({
+        title: parsed.title,
+        targetDate: parsed.targetDate,
+        cwd: ctx.cwd
+      });
+      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ''}`, 'info');
+      updateAnchorStatusBar(ctx, store);
+    }
+  });
+
+  // Alias /done for 1-step completion by display number or ID (e.g. `/done 1`)
+  pi.registerCommand('done', {
+    description: 'Complete an active anchor by row number or ID (e.g. /done 1)',
+    handler: async (args: string, ctx: ExtensionContext) => {
+      const target = (args || '').trim();
+      if (!target) {
+        await openAnchorDashboard(ctx, store);
+        return;
+      }
+      const resolvedId = resolveAnchorTarget(store, target, ctx.cwd);
+      if (!resolvedId) {
+        ctx.ui.notify(`⌖ Anchor not found: ${target}`, 'error');
+        return;
+      }
+      const settled = store.settle(resolvedId, { settledBy: 'manual-command' });
+      ctx.ui.notify(`⌖ Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, 'info');
       updateAnchorStatusBar(ctx, store);
     }
   });