kankaku 1.3.1 → 1.4.1

package/README.md

@@ -115,7 +115,7 @@ left untouched — and installs the slash commands:
   `--plugin-dir` flag needed**.
 
 It also installs the `/kankaku:*` slash commands (`/kankaku:report`,
-`/kankaku:status`, `/kankaku:task`, `/kankaku:sync`, …) as user commands under
+`/kankaku:status`, `/kankaku:task`, `/kankaku:target`, `/kankaku:sync`, …) as user commands under
 `~/.claude/commands/kankaku/<name>.md`, generated from the plugin's own
 `commands/*.md` with the plugin's absolute install path filled in. Setup
 lists each file it wrote or left unchanged; `kankaku doctor` reports Claude

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kankaku",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Terminal app that shows today's kankaku work across every project on disk",
   "keywords": [
     "pi-package",
@@ -38,9 +38,9 @@
   },
   "dependencies": {
     "ink": "^7.1.1",
-    "kankaku-pi": "^1.3.1",
-    "kankaku-claude": "^1.3.1",
+    "kankaku-claude": "^1.4.1",
     "kankaku-hub": "^0.3.0",
+    "kankaku-pi": "^1.4.1",
     "react": "^19.3.0"
   },
   "devDependencies": {

package/vendor/kankaku-pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kankaku-pi",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "pi extension that records agent work time per prompt, excluding waits for the user, with subagent linkage and task/session views",
   "license": "MIT",
   "author": "soyunninja",

package/vendor/kankaku-pi/src/adapters/cached-catalog.ts

@@ -61,6 +61,7 @@ export class CachedCatalog implements Catalog {
   private readonly deps: CachedCatalogDeps;
   private memo: CatalogSnapshot | undefined;
   private memoized = false;
+  private pendingAdoptions = new Set<Map<string, HubTask>>();
 
   constructor(deps: CachedCatalogDeps) {
     this.deps = deps;
@@ -74,6 +75,16 @@ export class CachedCatalog implements Catalog {
     return this.memo;
   }
 
+  /** Adopt a POST response without relying on an eventually-consistent list refresh. */
+  adoptTask(task: HubTask): void {
+    const snapshot = this.read();
+    if (!snapshot) throw new Error("Cannot adopt a task without a catalog snapshot");
+    const adopted = { ...snapshot, tasks: [...(snapshot.tasks ?? []).filter((item) => item.id !== task.id), task] };
+    this.writeDisk(adopted, true);
+    this.memo = adopted;
+    for (const pending of this.pendingAdoptions) pending.set(task.id, task);
+  }
+
   isStale(): boolean {
     const snapshot = this.read();
     if (!snapshot) return true;
@@ -82,6 +93,8 @@ export class CachedCatalog implements Catalog {
   }
 
   async refresh(signal?: AbortSignal): Promise<CatalogSnapshot | undefined> {
+    const adopted = new Map<string, HubTask>();
+    this.pendingAdoptions.add(adopted);
     try {
       const { clients, projects, tasks } = await this.deps.fetchCatalog(signal);
       const snapshot: CatalogSnapshot = {
@@ -89,7 +102,7 @@ export class CachedCatalog implements Catalog {
         url: this.deps.url,
         clients,
         projects,
-        ...(tasks !== undefined ? { tasks } : {}),
+        ...(tasks !== undefined || adopted.size > 0 ? { tasks: [...(tasks ?? []).filter((task) => !adopted.has(task.id)), ...adopted.values()] } : {}),
       };
       this.writeDisk(snapshot);
       this.memo = snapshot;
@@ -97,6 +110,8 @@ export class CachedCatalog implements Catalog {
       return snapshot;
     } catch {
       return undefined;
+    } finally {
+      this.pendingAdoptions.delete(adopted);
     }
   }
 
@@ -112,7 +127,7 @@ export class CachedCatalog implements Catalog {
     }
   }
 
-  private writeDisk(snapshot: CatalogSnapshot): void {
+  private writeDisk(snapshot: CatalogSnapshot, required = false): void {
     try {
       // This cache lives under `~/.kankaku` (machine-wide, not a project's
       // own KANKAKU_DIR) — but `~/.kankaku` itself is never mode-tightened
@@ -139,7 +154,8 @@ export class CachedCatalog implements Catalog {
       // Owner-only: this file names every client/project the machine's user has touched.
       writeFileSync(tmp, JSON.stringify(snapshot), { mode: OWNER_FILE_MODE });
       renameSync(tmp, this.deps.filePath);
-    } catch {
+    } catch (error) {
+      if (required) throw error;
       // Best-effort cache write: a failure here must not fail the refresh
       // itself, since the in-memory snapshot is still usable this process.
     }

package/vendor/kankaku-pi/src/adapters/kankaku-command.ts

@@ -194,7 +194,7 @@ const COMMAND_TOKENS = ["all", "tasks", "sessions", "client", "clients", "export
 /** Only offered when the hub is configured, so completions are unchanged for users without one. */
 const HUB_COMMAND_TOKENS = ["target", "task", "projects", "catalog", "sync", "backfill"];
 const TARGET_TOKENS = ["pick", "clear"];
-const TASK_TOKENS = ["pick", "clear"];
+const TASK_TOKENS = ["pick", "clear", "new"];
 const CATALOG_TOKENS = ["refresh"];
 const SYNC_TOKENS = ["all", "status"];
 
@@ -480,7 +480,7 @@ export function registerKankakuCommand(pi: ExtensionAPI, deps: KankakuCommandDep
   }
 
   /**
-   * Handle `/kankaku task [pick|clear]`; `rest` excludes the leading `task`
+   * Handle `/kankaku task [pick|clear|new <title> [--ref <externalRef>]]`; `rest` excludes the leading `task`
    * token. Default (no args) is `pick`. `pickTask`/`clearTask`
    * (`session-target.ts`) notify their own outcome directly, so this only
    * dispatches and refreshes the idle status line.
@@ -505,6 +505,19 @@ export function registerKankakuCommand(pi: ExtensionAPI, deps: KankakuCommandDep
       return;
     }
 
+    if (rest[0] === "new") {
+      const refIndex = rest.indexOf("--ref");
+      const title = rest.slice(1, refIndex === -1 ? undefined : refIndex).join(" ").trim();
+      const externalRef = refIndex === -1 ? undefined : rest[refIndex + 1]?.trim();
+      if (!title || (refIndex !== -1 && (!externalRef || refIndex !== rest.length - 2))) {
+        notifyError(ctx, new Error("usage: /kankaku task new <title> [--ref <externalRef>]"));
+        return;
+      }
+      await sessionTarget.newTask(pi, ctx, title, externalRef);
+      deps.refreshIdleStatus(ctx);
+      return;
+    }
+
     notifyError(ctx, new Error(`unknown task subcommand: ${rest.join(" ")}`));
   }
 
@@ -598,7 +611,8 @@ export function registerKankakuCommand(pi: ExtensionAPI, deps: KankakuCommandDep
       "When a hub (PocketBase) is configured: 'target' to show the effective client/project and its source, " +
       "'target pick' to run the picker again, 'target clear' to clear the session target, " +
       "'task' (or 'task pick') to link this session to an open/doing hub task of the effective project, " +
-      "'task clear' to drop the link, " +
+      "'task clear' to drop the link, 'task new <title> [--ref <externalRef>]' to create and link an open task; " +
+      "the visual task picker also offers creation, " +
       "'catalog refresh' to force a catalog refresh, 'projects' for per-project totals today ('projects all' for every day), " +
       "'sync' to push pending tasks to the hub ('sync all' for a full re-evaluation, 'sync status' for the watermark/pending count/last error), " +
       "'backfill' to run a full sync and report how many tasks went to Sin determinar, grouped by their old label. " +

package/vendor/kankaku-pi/src/adapters/pocketbase-catalog.ts

@@ -23,6 +23,23 @@ interface TaskRecord extends PocketBaseRecord {
   external_ref?: string;
 }
 
+export interface CreateHubTaskInput {
+  title: string;
+  projectId: string;
+  externalRef?: string;
+}
+
+/** Explicit user-driven creation; never called from hook paths. */
+export async function createHubTask(client: PocketBaseClient, input: CreateHubTaskInput, signal?: AbortSignal): Promise<HubTask> {
+  const record = await client.request<TaskRecord>("POST", "/api/collections/tasks/records", {
+    title: input.title,
+    project: input.projectId,
+    status: "open",
+    ...(input.externalRef !== undefined ? { external_ref: input.externalRef } : {}),
+  }, signal);
+  return mapTask(record);
+}
+
 const TASK_STATUSES = new Set(["open", "doing", "done"]);
 
 function mapClient(record: ClientRecord): Client {

package/vendor/kankaku-pi/src/adapters/session-target.ts

@@ -3,6 +3,7 @@ import { formatWorkTargetLabel, resolveWorkTarget, resolveWorkTargetSource } fro
 import type { WorkTarget, WorkTargetCandidate, WorkTargetSessionOverride, WorkTargetSourceName } from "../domain/work-target.ts";
 import type { WorkRole } from "../domain/work-record.ts";
 import type { Catalog, CatalogSnapshot } from "../ports/catalog.ts";
+import type { TaskCreator } from "./target-picker.ts";
 import { pickHubTask, pickTarget } from "./target-picker.ts";
 
 /** Persisted as a `kankaku-target` custom session entry so the session-level target survives a reload. */
@@ -14,8 +15,7 @@ export interface KankakuTargetEntryData {
   /**
    * A hub task picked for this session (`/kankaku task pick`). Session-only:
    * never written to the project's `.kankaku/config.json`, and dropped by
-   * any target change (`pick`/`setExplicit`/`clear`/`ensurePicked`'s
-   * silent resolution) since those all build a fresh candidate without it.
+   * target changes unless a new task is selected in the target picker.
    */
   hubTaskId?: string;
 }
@@ -25,6 +25,8 @@ export const TARGET_ENTRY_TYPE = "kankaku-target";
 export interface SessionTargetDeps {
   role: WorkRole;
   catalog: Catalog;
+  /** Creates and adopts the returned task before linking it. */
+  createTask?: TaskCreator;
   /** Lazily reads `clientId`/`projectId` from `<kankaku dir>/config.json`. */
   resolveProjectConfigIds: () => WorkTargetCandidate | undefined;
   /** Persist `clientId`/`projectId` into `<kankaku dir>/config.json`, merging existing keys. */
@@ -81,6 +83,8 @@ export interface SessionTarget {
   pickTask(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void>;
   /** `/kankaku task clear`: drops the linked hub task, keeping the rest of the session target. A no-op when none is linked. */
   clearTask(pi: ExtensionAPI): void;
+  /** Create through the shared creator and link only in the current session. */
+  newTask(pi: ExtensionAPI, ctx: ExtensionContext, title: string, externalRef?: string): Promise<void>;
   /**
    * Set the linked hub task directly, bypassing the picker — the panel's
    * target screen (`adapters/panel/screens/target.ts`) uses this once the
@@ -291,7 +295,7 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
   }
 
   async function runPicker(pi: ExtensionAPI, ctx: ExtensionContext, snapshot: CatalogSnapshot): Promise<void> {
-    const result = await pickTarget(ctx, snapshot);
+    const result = await pickTarget(ctx, snapshot, deps.createTask);
 
     if (result.kind === "skipped") {
       sessionOverride = "skipped";
@@ -299,13 +303,17 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
       return;
     }
 
-    const ids = candidateFrom(result.target);
+    const projectIds = candidateFrom(result.target);
+    const ids: WorkTargetCandidate = {
+      ...projectIds,
+      ...(result.target.hubTaskId !== undefined ? { hubTaskId: result.target.hubTaskId } : {}),
+    };
     sessionOverride = ids;
     pi.appendEntry<KankakuTargetEntryData>(TARGET_ENTRY_TYPE, entryDataFrom(ids));
 
     const remember = await ctx.ui.confirm("kankaku", `Remember ${formatWorkTargetLabel(result.target)} for this repository?`);
     if (remember) {
-      deps.persistProjectConfig(ids);
+      deps.persistProjectConfig(projectIds);
     }
   }
 
@@ -390,7 +398,7 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
     }
 
     const tasks = deps.catalog.read()?.tasks ?? [];
-    const result = await pickHubTask(ctx, tasks, target.projectId);
+    const result = await pickHubTask(ctx, tasks, target.projectId, deps.createTask);
 
     if (result.kind === "empty") {
       ctx.ui.notify(`kankaku: No open tasks for ${target.projectName ?? target.projectId} in the hub`, "warning");
@@ -404,6 +412,19 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
     if (updated) ctx.ui.notify(`kankaku: task set to ${formatWorkTargetLabel(updated)}`);
   }
 
+  async function newTask(pi: ExtensionAPI, ctx: ExtensionContext, title: string, externalRef?: string): Promise<void> {
+    if (deps.role !== "orchestrator" || !ctx.hasUI) return;
+    const target = effectiveTarget();
+    if (!target || target.projectId === undefined) {
+      ctx.ui.notify("kankaku: Pick a client and project first (/kankaku target pick)", "warning");
+      return;
+    }
+    if (!deps.createTask) throw new Error("task creation is not configured");
+    const task = await deps.createTask(target.projectId, title, externalRef);
+    setTask(pi, task.id);
+    ctx.ui.notify(`kankaku: created and linked: ${task.title}`);
+  }
+
   function clearTask(pi: ExtensionAPI): void {
     if (sessionOverride === undefined || sessionOverride === "skipped") return;
     if (sessionOverride.hubTaskId === undefined) return;
@@ -420,6 +441,7 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
     clear,
     pickTask,
     clearTask,
+    newTask,
     setTask,
     rememberTarget,
     effectiveTarget,

package/vendor/kankaku-pi/src/adapters/target-picker.ts

@@ -3,10 +3,13 @@ import type { Client, HubTask, Project, WorkTarget } from "../domain/work-target
 
 const SKIP_OPTION = "— skip —";
 const NO_PROJECT_OPTION = "(no project)";
+const CREATE_OPTION = "＋ create task ＋";
+export type TaskCreator = (projectId: string, title: string, externalRef?: string) => Promise<HubTask>;
 
 export interface PickerCatalog {
   clients: Client[];
   projects: Project[];
+  tasks?: HubTask[];
 }
 
 export type PickResult = { kind: "picked"; target: WorkTarget } | { kind: "skipped" };
@@ -36,14 +39,15 @@ function labelOptions<T extends { name: string; code?: string }>(items: T[]): La
 }
 
 /**
- * Run the client/project picker (`ctx.ui.select`) against an already-loaded
+ * Run the client/project/task picker (`ctx.ui.select`) against an already-loaded
  * catalog snapshot. Pure UI interaction: no network, no persistence — the
  * caller (`session-target.ts`) decides what to do with the result.
  *
- * Declining at either step — choosing "— skip —" or dismissing the dialog
+ * Declining at either client/project step — choosing "— skip —" or dismissing the dialog
  * (`undefined`) — cancels the whole pick, not just that step.
+ * Skipping the optional task step keeps the selected client/project.
  */
-export async function pickTarget(ctx: ExtensionContext, catalog: PickerCatalog): Promise<PickResult> {
+export async function pickTarget(ctx: ExtensionContext, catalog: PickerCatalog, createTask?: TaskCreator): Promise<PickResult> {
   const pickableClients = catalog.clients.filter((client) => client.active && !client.unassigned);
   const clientOptions = labelOptions(pickableClients);
 
@@ -78,6 +82,14 @@ export async function pickTarget(ctx: ExtensionContext, catalog: PickerCatalog):
       : {}),
   };
 
+  if (project) {
+    const taskResult = await pickHubTask(ctx, catalog.tasks ?? [], project.id, createTask);
+    if (taskResult.kind === "picked") {
+      target.hubTaskId = taskResult.task.id;
+      target.hubTaskTitle = taskResult.task.title;
+    }
+  }
+
   return { kind: "picked", target };
 }
 
@@ -112,13 +124,29 @@ function labelTaskOptions(tasks: HubTask[]): LabeledOption<HubTask>[] {
  * has no open/doing task, so the caller can tell "nothing to pick from"
  * apart from "the user skipped".
  */
-export async function pickHubTask(ctx: ExtensionContext, tasks: HubTask[], projectId: string): Promise<PickHubTaskResult> {
+export async function pickHubTask(ctx: ExtensionContext, tasks: HubTask[], projectId: string, createTask?: TaskCreator): Promise<PickHubTaskResult> {
   const pickable = tasks.filter((task) => task.status !== "done" && task.projectId === projectId);
-  if (pickable.length === 0) return { kind: "empty" };
+  if (pickable.length === 0 && !createTask) return { kind: "empty" };
 
   const taskOptions = labelTaskOptions(pickable);
-  const choice = await ctx.ui.select("kankaku — task", [...taskOptions.map((option) => option.label), SKIP_OPTION]);
+  const labels = taskOptions.map((option) => option.label);
+  let createOption = CREATE_OPTION;
+  for (let suffix = 2; labels.includes(createOption); suffix++) {
+    createOption = `${CREATE_OPTION} (${suffix})`;
+  }
+  const choice = await ctx.ui.select("kankaku — task", [...labels, ...(createTask ? [createOption] : []), SKIP_OPTION]);
   if (choice === undefined || choice === SKIP_OPTION) return { kind: "skipped" };
+  if (choice === createOption && createTask) {
+    const title = (await ctx.ui.input("kankaku — task title"))?.trim();
+    if (!title) return { kind: "skipped" };
+    const externalRef = (await ctx.ui.input("kankaku — external reference (optional)"))?.trim();
+    try {
+      return { kind: "picked", task: await createTask(projectId, title, externalRef || undefined) };
+    } catch {
+      ctx.ui.notify("kankaku: task creation failed; no task linked", "error");
+      return { kind: "skipped" };
+    }
+  }
 
   const task = taskOptions.find((option) => option.label === choice)?.item;
   if (!task) return { kind: "skipped" };

package/vendor/kankaku-pi/src/extension.ts

@@ -11,7 +11,7 @@ import { LazyProjectClientSource, LazyProjectTargetSource } from "./adapters/pro
 import { LazyExportWriter } from "./adapters/export-writer.ts";
 import { resolveHubCredentials, safeHomeDir } from "./adapters/hub-credentials.ts";
 import { PocketBaseClient } from "./adapters/pocketbase-client.ts";
-import { createPocketBaseCatalogFetcher } from "./adapters/pocketbase-catalog.ts";
+import { createHubTask, createPocketBaseCatalogFetcher } from "./adapters/pocketbase-catalog.ts";
 import { CachedCatalog } from "./adapters/cached-catalog.ts";
 import { createSessionTarget } from "./adapters/session-target.ts";
 import { resolveKankakuDir, resolveWritableTarget } from "./adapters/kankaku-dir.ts";
@@ -212,7 +212,7 @@ export default function kankaku(pi: ExtensionAPI): void {
     // when no home directory is available so an env-only hub configuration
     // still works without one (the cache just does not survive a reboot).
     const homeDirForCache = safeHomeDir(homedir) ?? tmpdir();
-    catalog = new CachedCatalog({
+    const cachedCatalog = new CachedCatalog({
       // Machine-wide cache: several projects on the same machine share one
       // catalog fetch, and it survives across projects.
       filePath: join(homeDirForCache, ".kankaku", "catalog.json"),
@@ -221,10 +221,16 @@ export default function kankaku(pi: ExtensionAPI): void {
       fetchCatalog: createPocketBaseCatalogFetcher(client),
     });
 
+    catalog = cachedCatalog;
     const projectTarget = new LazyProjectTargetSource(config.dir);
     sessionTarget = createSessionTarget({
       role,
       catalog,
+      createTask: async (projectId, title, externalRef) => {
+        const task = await createHubTask(client, { projectId, title, ...(externalRef ? { externalRef } : {}) });
+        cachedCatalog.adoptTask(task);
+        return task;
+      },
       resolveProjectConfigIds: () => projectTarget.read(),
       persistProjectConfig: (ids) => projectTarget.write(ids),
     });