trekoon 0.2.0 → 0.2.4

package/src/commands/session.ts

@@ -0,0 +1,223 @@
+import type { Database } from "bun:sqlite";
+
+import { unexpectedFailureResult } from "./error-utils";
+import { buildTaskReadiness, type DependencyBlocker } from "./task-readiness";
+
+import { TrackerDomain } from "../domain/tracker-domain";
+import { okResult } from "../io/output";
+import { type CliContext, type CliResult } from "../runtime/command-types";
+import { openTrekoonDatabase, type TrekoonDatabase } from "../storage/database";
+import { countBranchEventsSince } from "../sync/branch-db";
+import { persistGitContext, resolveGitContext } from "../sync/git-context";
+import { type GitContextSnapshot, type SyncStatusSummary } from "../sync/types";
+
+const DEFAULT_SOURCE_BRANCH = "main";
+
+interface SessionReadiness {
+  readonly readyCount: number;
+  readonly blockedCount: number;
+}
+
+interface NextCandidate {
+  readonly id: string;
+  readonly epicId: string;
+  readonly title: string;
+  readonly description: string;
+  readonly status: string;
+  readonly subtasks: ReadonlyArray<{
+    readonly id: string;
+    readonly taskId: string;
+    readonly title: string;
+    readonly description: string;
+    readonly status: string;
+  }>;
+}
+
+interface SessionResult {
+  readonly diagnostics: {
+    readonly storageMode: string;
+    readonly recoveryRequired: boolean;
+    readonly recoveryStatus: string;
+  };
+  readonly sync: {
+    readonly ahead: number;
+    readonly behind: number;
+    readonly pendingConflicts: number;
+    readonly git: GitContextSnapshot;
+  };
+  readonly next: NextCandidate | null;
+  readonly nextDeps: ReadonlyArray<DependencyBlocker>;
+  readonly readiness: SessionReadiness;
+}
+
+function countAheadLocal(db: Database, currentBranch: string | null, sourceBranch: string): number {
+  if (!currentBranch || currentBranch === sourceBranch) {
+    return 0;
+  }
+
+  const row = db
+    .query(
+      `
+      SELECT COUNT(*) AS count
+      FROM events
+      WHERE git_branch = @branch;
+      `,
+    )
+    .get({ "@branch": currentBranch }) as { count: number } | null;
+
+  return row?.count ?? 0;
+}
+
+function countPendingConflictsLocal(db: Database): number {
+  const row = db
+    .query("SELECT COUNT(*) AS count FROM sync_conflicts WHERE resolution = 'pending';")
+    .get() as { count: number } | null;
+
+  return row?.count ?? 0;
+}
+
+function loadCursorLocal(
+  db: Database,
+  worktreePath: string,
+  sourceBranch: string,
+): { cursor_token: string } | null {
+  return db
+    .query(
+      `
+      SELECT cursor_token
+      FROM sync_cursors
+      WHERE owner_scope = 'worktree'
+        AND owner_worktree_path = ?
+        AND source_branch = ?
+      LIMIT 1;
+      `,
+    )
+    .get(worktreePath, sourceBranch) as { cursor_token: string } | null;
+}
+
+function resolveSyncStatus(
+  database: TrekoonDatabase,
+  cwd: string,
+  sourceBranch: string,
+): SyncStatusSummary {
+  const git: GitContextSnapshot = resolveGitContext(cwd);
+  persistGitContext(database.db, git);
+
+  const cursor = loadCursorLocal(database.db, git.worktreePath, sourceBranch);
+  const cursorToken: string = cursor?.cursor_token ?? "0:";
+  const onSourceBranch: boolean = git.branchName !== null && git.branchName === sourceBranch;
+
+  return {
+    sourceBranch,
+    ahead: countAheadLocal(database.db, git.branchName, sourceBranch),
+    behind: onSourceBranch ? 0 : countBranchEventsSince(database.db, sourceBranch, cursorToken),
+    pendingConflicts: countPendingConflictsLocal(database.db),
+    sameBranch: onSourceBranch,
+    git,
+  };
+}
+
+
+function formatSessionHuman(result: SessionResult): string {
+  const lines: string[] = [];
+
+  lines.push("=== Session ===");
+  lines.push(`Storage mode: ${result.diagnostics.storageMode}`);
+  lines.push(`Recovery required: ${result.diagnostics.recoveryRequired}`);
+  lines.push(`Recovery status: ${result.diagnostics.recoveryStatus}`);
+
+  lines.push("");
+  lines.push("=== Sync ===");
+  lines.push(`Source branch: ${DEFAULT_SOURCE_BRANCH}`);
+  lines.push(`Ahead: ${result.sync.ahead}`);
+  lines.push(`Behind: ${result.sync.behind}`);
+  lines.push(`Pending conflicts: ${result.sync.pendingConflicts}`);
+  lines.push(`Branch: ${result.sync.git.branchName ?? "(detached)"}`);
+
+  lines.push("");
+  lines.push("=== Readiness ===");
+  lines.push(`Ready: ${result.readiness.readyCount}`);
+  lines.push(`Blocked: ${result.readiness.blockedCount}`);
+
+  lines.push("");
+  lines.push("=== Next Task ===");
+  if (result.next === null) {
+    lines.push("No ready tasks.");
+  } else {
+    lines.push(`${result.next.id} | epic=${result.next.epicId} | ${result.next.title} | ${result.next.status}`);
+    lines.push(`Description: ${result.next.description}`);
+    if (result.next.subtasks.length > 0) {
+      lines.push("Subtasks:");
+      for (const subtask of result.next.subtasks) {
+        lines.push(`  ${subtask.id} | ${subtask.title} | ${subtask.status}`);
+      }
+    } else {
+      lines.push("Subtasks: none");
+    }
+  }
+
+  lines.push("");
+  lines.push("=== Next Task Deps ===");
+  if (result.nextDeps.length === 0) {
+    lines.push("No blockers.");
+  } else {
+    for (const dep of result.nextDeps) {
+      lines.push(`${dep.id} | kind=${dep.kind} | status=${dep.status}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export async function runSession(context: CliContext): Promise<CliResult> {
+  let database: TrekoonDatabase | undefined;
+
+  try {
+    database = openTrekoonDatabase(context.cwd);
+    const diagnostics = database.diagnostics;
+
+    const syncSummary = resolveSyncStatus(database, context.cwd, DEFAULT_SOURCE_BRANCH);
+    const domain = new TrackerDomain(database.db);
+    const readiness = buildTaskReadiness(domain, undefined);
+    const topCandidate = readiness.candidates[0] ?? null;
+
+    let nextTask: NextCandidate | null = null;
+    if (topCandidate !== null) {
+      const tree = domain.buildTaskTreeDetailed(topCandidate.task.id);
+      nextTask = tree;
+    }
+
+    const result: SessionResult = {
+      diagnostics: {
+        storageMode: diagnostics.storageMode,
+        recoveryRequired: diagnostics.recoveryRequired,
+        recoveryStatus: diagnostics.recoveryStatus,
+      },
+      sync: {
+        ahead: syncSummary.ahead,
+        behind: syncSummary.behind,
+        pendingConflicts: syncSummary.pendingConflicts,
+        git: syncSummary.git,
+      },
+      next: nextTask,
+      nextDeps: topCandidate?.blockerSummary.blockedBy ?? [],
+      readiness: {
+        readyCount: readiness.summary.readyCount,
+        blockedCount: readiness.summary.blockedCount,
+      },
+    };
+
+    return okResult({
+      command: "session",
+      human: formatSessionHuman(result),
+      data: result,
+    });
+  } catch (error: unknown) {
+    return unexpectedFailureResult(error, {
+      command: "session",
+      human: "Unexpected session command failure",
+    });
+  } finally {
+    database?.close();
+  }
+}

package/src/commands/skills.ts

@@ -16,8 +16,6 @@ const EDITOR_NAMES = ["opencode", "claude", "pi"] as const;
 const ALLOW_OUTSIDE_REPO_FLAG = "allow-outside-repo";
 
 type EditorName = (typeof EDITOR_NAMES)[number];
-type LinkStateStatus = "missing" | "valid" | "conflict";
-
 interface InstallOutcome {
   readonly sourcePath: string;
   readonly installedPath: string;
@@ -32,20 +30,22 @@ interface LinkTargetValidation {
   readonly outsideRepoLink: boolean;
 }
 
-interface LinkState {
+type UpdateLinkAction = "created" | "refreshed" | "skipped_conflict" | "skipped_no_editor_dir";
+
+interface UpdateLinkEntry {
   readonly editor: EditorName;
   readonly linkPath: string;
   readonly expectedTarget: string;
-  readonly status: LinkStateStatus;
-  readonly existingTarget: string | null;
+  readonly action: UpdateLinkAction;
   readonly conflictCode: "non_link" | "wrong_target" | null;
+  readonly existingTarget: string | null;
 }
 
 interface UpdateOutcome {
   readonly sourcePath: string;
   readonly installedPath: string;
   readonly installedDir: string;
-  readonly links: readonly LinkState[];
+  readonly links: readonly UpdateLinkEntry[];
 }
 
 function invalidArgs(message: string): CliResult {
@@ -215,6 +215,18 @@ function resolveDefaultLinkPath(cwd: string, editor: EditorName): string {
   return join(resolveLinkRoot(cwd, editor, undefined), "trekoon");
 }
 
+function resolveEditorConfigDir(cwd: string, editor: EditorName): string {
+  if (editor === "opencode") {
+    return join(cwd, ".opencode");
+  }
+
+  if (editor === "claude") {
+    return join(cwd, ".claude");
+  }
+
+  return join(cwd, ".pi");
+}
+
 function installCanonicalSkill(cwd: string): CliResult | { sourcePath: string; installedPath: string; installedDir: string } {
   const sourcePath: string = resolveBundledSkillFilePath();
   if (!existsSync(sourcePath)) {
@@ -323,56 +335,6 @@ function replaceOrCreateSymlink(
   return null;
 }
 
-function inspectDefaultLink(cwd: string, editor: EditorName, installedDir: string): LinkState {
-  const linkPath: string = resolveDefaultLinkPath(cwd, editor);
-  const expectedTarget: string = resolve(installedDir);
-
-  if (!existsSync(linkPath)) {
-    return {
-      editor,
-      linkPath,
-      expectedTarget,
-      status: "missing",
-      existingTarget: null,
-      conflictCode: null,
-    };
-  }
-
-  const entry = lstatSync(linkPath);
-  if (!entry.isSymbolicLink()) {
-    return {
-      editor,
-      linkPath,
-      expectedTarget,
-      status: "conflict",
-      existingTarget: null,
-      conflictCode: "non_link",
-    };
-  }
-
-  const existingRawTarget: string = readlinkSync(linkPath);
-  const existingTarget: string = toAbsolutePath(dirname(linkPath), existingRawTarget);
-  if (existingTarget !== expectedTarget) {
-    return {
-      editor,
-      linkPath,
-      expectedTarget,
-      status: "conflict",
-      existingTarget,
-      conflictCode: "wrong_target",
-    };
-  }
-
-  return {
-    editor,
-    linkPath,
-    expectedTarget,
-    status: "valid",
-    existingTarget,
-    conflictCode: null,
-  };
-}
-
 function runSkillsInstall(context: CliContext): CliResult {
   const parsed = parseArgs(context.args);
   const missingValue = readMissingOptionValue(parsed.missingOptionValues, "editor", "to");
@@ -520,6 +482,77 @@ function runSkillsInstall(context: CliContext): CliResult {
   });
 }
 
+function updateEditorLink(
+  cwd: string,
+  editor: EditorName,
+  installedDir: string,
+): UpdateLinkEntry {
+  const linkPath: string = resolveDefaultLinkPath(cwd, editor);
+  const expectedTarget: string = resolve(installedDir);
+  const editorConfigDir: string = resolveEditorConfigDir(cwd, editor);
+
+  if (!existsSync(editorConfigDir)) {
+    return {
+      editor,
+      linkPath,
+      expectedTarget,
+      action: "skipped_no_editor_dir",
+      conflictCode: null,
+      existingTarget: null,
+    };
+  }
+
+  if (!existsSync(linkPath)) {
+    mkdirSync(dirname(linkPath), { recursive: true });
+    symlinkSync(expectedTarget, linkPath, "dir");
+    return {
+      editor,
+      linkPath,
+      expectedTarget,
+      action: "created",
+      conflictCode: null,
+      existingTarget: null,
+    };
+  }
+
+  const entry = lstatSync(linkPath);
+  if (!entry.isSymbolicLink()) {
+    return {
+      editor,
+      linkPath,
+      expectedTarget,
+      action: "skipped_conflict",
+      conflictCode: "non_link",
+      existingTarget: null,
+    };
+  }
+
+  const existingRawTarget: string = readlinkSync(linkPath);
+  const existingTarget: string = toAbsolutePath(dirname(linkPath), existingRawTarget);
+
+  if (existingTarget !== expectedTarget) {
+    return {
+      editor,
+      linkPath,
+      expectedTarget,
+      action: "skipped_conflict",
+      conflictCode: "wrong_target",
+      existingTarget,
+    };
+  }
+
+  rmSync(linkPath, { force: true });
+  symlinkSync(expectedTarget, linkPath, "dir");
+  return {
+    editor,
+    linkPath,
+    expectedTarget,
+    action: "refreshed",
+    conflictCode: null,
+    existingTarget,
+  };
+}
+
 function runSkillsUpdate(context: CliContext): CliResult {
   const parsed = parseArgs(context.args);
   if (parsed.positional.length > 1) {
@@ -544,8 +577,8 @@ function runSkillsUpdate(context: CliContext): CliResult {
     });
   }
 
-  const links: readonly LinkState[] = EDITOR_NAMES.map((editor) =>
-    inspectDefaultLink(context.cwd, editor, installResult.installedDir),
+  const links: readonly UpdateLinkEntry[] = EDITOR_NAMES.map((editor) =>
+    updateEditorLink(context.cwd, editor, installResult.installedDir),
   );
 
   const outcome: UpdateOutcome = {
@@ -557,12 +590,16 @@ function runSkillsUpdate(context: CliContext): CliResult {
 
   const linkSummary: string = outcome.links
     .map((entry) => {
-      if (entry.status === "missing") {
-        return `- ${entry.editor}: missing (${entry.linkPath})`;
+      if (entry.action === "created") {
+        return `- ${entry.editor}: created (${entry.linkPath} -> ${entry.expectedTarget})`;
+      }
+
+      if (entry.action === "refreshed") {
+        return `- ${entry.editor}: refreshed (${entry.linkPath} -> ${entry.expectedTarget})`;
       }
 
-      if (entry.status === "valid") {
-        return `- ${entry.editor}: valid (${entry.linkPath} -> ${entry.expectedTarget})`;
+      if (entry.action === "skipped_no_editor_dir") {
+        return `- ${entry.editor}: skipped (no editor config dir)`;
       }
 
       if (entry.conflictCode === "non_link") {
@@ -579,7 +616,7 @@ function runSkillsUpdate(context: CliContext): CliResult {
       "Updated Trekoon skill in canonical path.",
       `Source: ${outcome.sourcePath}`,
       `Installed file: ${outcome.installedPath}`,
-      "Default link states:",
+      "Editor links:",
       linkSummary,
     ].join("\n"),
     data: {