pi-repoprompt-mcp 0.5.5 → 0.6.1

package/extensions/repoprompt-mcp/src/binding.ts

@@ -754,7 +754,7 @@ function parseTabFromJson(raw: unknown): RpTab | null {
   }
 
   const obj = raw as Record<string, unknown>;
-  const idRaw = obj.id ?? obj.tabId ?? obj.tab_id ?? obj.uuid;
+  const idRaw = obj.contextId ?? obj.context_id ?? obj.id ?? obj.tabId ?? obj.tab_id ?? obj.uuid;
   if (typeof idRaw !== "string" || !idRaw.trim()) {
     return null;
   }
@@ -786,7 +786,20 @@ function collectTabsFromJson(raw: unknown): RpTab[] {
   }
 
   const obj = raw as Record<string, unknown>;
-  const containers = [obj.tabs, obj.tab, obj.createdTab, obj.created_tab, obj.selectedTab, obj.selected_tab];
+  const containers = [
+    obj.tabs,
+    obj.contexts,
+    obj.tab,
+    obj.context,
+    obj.createdTab,
+    obj.created_tab,
+    obj.createdContext,
+    obj.created_context,
+    obj.selectedTab,
+    obj.selected_tab,
+    obj.selectedContext,
+    obj.selected_context,
+  ];
 
   for (const candidate of containers) {
     const parsed = collectTabsFromJson(candidate);
@@ -835,7 +848,26 @@ function dedupeTabs(tabs: RpTab[]): RpTab[] {
 
 function parseTabLine(line: string): RpTab | null {
   const trimmed = line.trim();
-  if (!trimmed || !trimmed.includes("`")) {
+  if (!trimmed) {
+    return null;
+  }
+
+  const contextMatch = trimmed.match(/^[\u2022-]\s*(.+?)(?:\s+\[([^\]]+)\])?\s+—\s+context_id:\s*`([^`]+)`/i);
+  if (contextMatch) {
+    const state = contextMatch[2] ?? "";
+    return {
+      id: contextMatch[3].trim(),
+      name: stripTrailingTabStateAnnotations(contextMatch[1].trim()) || contextMatch[3].trim(),
+      isActive: /\bactive\b|\bin-focus\b/i.test(state)
+        ? true
+        : /\bout-of-focus\b/i.test(state)
+          ? false
+          : undefined,
+      isBound: /\bbound\b/i.test(state) ? true : undefined,
+    };
+  }
+
+  if (!trimmed.includes("`")) {
     return null;
   }
 
@@ -869,6 +901,17 @@ function parseTabLine(line: string): RpTab | null {
   };
 }
 
+function parseTabsFromBindContextText(text: string): RpTab[] {
+  return dedupeTabs(
+    text
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => /—\s+context_id:\s*`[^`]+`/i.test(line))
+      .map(parseTabLine)
+      .filter((tab): tab is RpTab => tab !== null)
+  );
+}
+
 export function parseTabList(text: string): RpTab[] {
   const tabs: RpTab[] = [];
   let lastTab: RpTab | null = null;
@@ -899,132 +942,129 @@ function parseTabsFromJson(value: unknown): RpTab[] | null {
   return tabs.length > 0 ? dedupeTabs(tabs) : null;
 }
 
-function parseChatCountFromJson(value: unknown): number | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  if (Array.isArray(value)) {
-    return value.length;
+function findLiveTab(tabs: RpTab[], reference: string | undefined): RpTab | null {
+  if (!reference) {
+    return null;
   }
 
-  if (typeof value !== "object") {
-    return undefined;
-  }
+  return tabs.find((tab) => tab.id === reference || tab.name === reference) ?? null;
+}
 
-  const obj = value as Record<string, unknown>;
-  const directCount = parseCountMaybe(
-    obj.count ?? obj.chatCount ?? obj.chat_count ?? obj.total ?? obj.totalCount ?? obj.total_count
-  );
-  if (directCount !== undefined) {
-    return directCount;
-  }
+function isExplicitlyEmptyTab(tab: RpTab): boolean {
+  return tab.selectedFileCount === 0;
+}
 
-  for (const key of ["chats", "sessions", "items", "results"]) {
-    const candidate = obj[key];
-    if (Array.isArray(candidate)) {
-      return candidate.length;
-    }
-  }
+function orderReusableTabCandidates(tabs: RpTab[]): RpTab[] {
+  const ordered = [
+    ...tabs.filter((tab) => tab.isBound === true),
+    ...tabs.filter((tab) => tab.isBound !== true && tab.isActive === true),
+    ...tabs.filter((tab) => tab.isBound !== true && tab.isActive !== true),
+  ];
 
-  return undefined;
+  return ordered.filter((tab, index) => ordered.findIndex((candidate) => candidate.id === tab.id) === index);
 }
 
-function parseChatCountFromText(text: string): number | undefined {
-  const countMatch = text.match(/\bCount\b[^\d]*([\d,]+)/i);
-  if (countMatch?.[1]) {
-    return parseCountMaybe(countMatch[1]);
-  }
+function parseOracleSessionTabPrefixes(text: string): Set<string> {
+  const prefixes = new Set<string>();
 
-  if (/\bNo chats\b/i.test(text)) {
-    return 0;
+  for (const match of text.matchAll(/\btab=([A-F0-9-]{6,})(?:…|\b)/gi)) {
+    const prefix = match[1]?.trim().toUpperCase();
+    if (prefix) {
+      prefixes.add(prefix);
+    }
   }
 
-  const sessionCount = text
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => /^•\s*\[[^\]]+\]/.test(line)).length;
-
-  return sessionCount > 0 ? sessionCount : undefined;
+  return prefixes;
 }
 
-async function fetchTabChatCount(
-  tabId: string,
+async function fetchOracleSessionTabPrefixes(
+  windowId: number,
   client: ReturnType<typeof getRpClient> = getRpClient()
-): Promise<number | undefined> {
-  if (!client.isConnected) {
-    return undefined;
-  }
-
-  const chatsToolName = resolveToolName(client.tools, "chats");
-  if (!chatsToolName) {
-    return undefined;
+): Promise<Set<string> | null> {
+  const oracleUtilsToolName = resolveToolName(client.tools, "oracle_utils");
+  if (!oracleUtilsToolName) {
+    return null;
   }
 
-  const result = await client.callTool(chatsToolName, {
-    action: "list",
-    scope: "tab",
-    tab_id: tabId,
-    limit: 1,
+  const result = await client.callTool(oracleUtilsToolName, {
+    op: "sessions",
+    limit: 200,
+    _windowID: windowId,
   });
 
   if (result.isError) {
-    return undefined;
-  }
-
-  const countFromJson = parseChatCountFromJson(extractJsonContent(result.content));
-  if (countFromJson !== undefined) {
-    return countFromJson;
+    return null;
   }
 
-  return parseChatCountFromText(extractTextContent(result.content));
+  return parseOracleSessionTabPrefixes(extractTextContent(result.content));
 }
 
-function findLiveTab(tabs: RpTab[], reference: string | undefined): RpTab | null {
-  if (!reference) {
-    return null;
+function tabHasOracleHistory(tabId: string, sessionTabPrefixes: Set<string> | null): boolean {
+  if (!sessionTabPrefixes || sessionTabPrefixes.size === 0) {
+    return false;
   }
 
-  return tabs.find((tab) => tab.id === reference || tab.name === reference) ?? null;
-}
+  const normalizedTabId = tabId.trim().toUpperCase();
+  for (const prefix of sessionTabPrefixes) {
+    if (normalizedTabId.startsWith(prefix)) {
+      return true;
+    }
+  }
 
-function isExplicitlyEmptyTab(tab: RpTab): boolean {
-  return tab.selectedFileCount === 0;
+  return false;
 }
 
-async function isSafeReusableTab(
+async function hasEmptySelection(
+  windowId: number,
   tab: RpTab,
   client: ReturnType<typeof getRpClient> = getRpClient()
 ): Promise<boolean> {
-  if (!isExplicitlyEmptyTab(tab)) {
+  if (isExplicitlyEmptyTab(tab)) {
+    return true;
+  }
+
+  const manageSelectionToolName = resolveToolName(client.tools, "manage_selection");
+  if (!manageSelectionToolName) {
     return false;
   }
 
-  const chatCount = await fetchTabChatCount(tab.id, client);
-  return chatCount === 0;
-}
+  const result = await client.callTool(manageSelectionToolName, {
+    op: "get",
+    view: "summary",
+    _windowID: windowId,
+    context_id: tab.id,
+  });
 
-function orderReusableEmptyTabs(tabs: RpTab[]): RpTab[] {
-  const emptyTabs = tabs.filter(isExplicitlyEmptyTab);
-  if (emptyTabs.length === 0) {
-    return [];
+  if (result.isError) {
+    return false;
   }
 
-  const ordered = [
-    ...emptyTabs.filter((tab) => tab.isBound === true),
-    ...emptyTabs.filter((tab) => tab.isBound !== true && tab.isActive === true),
-    ...emptyTabs.filter((tab) => tab.isBound !== true && tab.isActive !== true),
-  ];
+  const text = extractTextContent(result.content);
+  return /\b0 total tokens\b/i.test(text);
+}
 
-  return ordered.filter((tab, index) => ordered.findIndex((candidate) => candidate.id === tab.id) === index);
+async function isSafeReusableTab(
+  windowId: number,
+  tab: RpTab,
+  sessionTabPrefixes: Set<string> | null,
+  client: ReturnType<typeof getRpClient> = getRpClient()
+): Promise<boolean> {
+  if (tabHasOracleHistory(tab.id, sessionTabPrefixes)) {
+    return false;
+  }
+
+  return await hasEmptySelection(windowId, tab, client);
 }
 
 async function findReusableSafeTab(
+  windowId: number,
   tabs: RpTab[],
   client: ReturnType<typeof getRpClient> = getRpClient()
 ): Promise<RpTab | null> {
-  for (const tab of orderReusableEmptyTabs(tabs)) {
-    if (await isSafeReusableTab(tab, client)) {
+  const sessionTabPrefixes = await fetchOracleSessionTabPrefixes(windowId, client);
+
+  for (const tab of orderReusableTabCandidates(tabs)) {
+    if (await isSafeReusableTab(windowId, tab, sessionTabPrefixes, client)) {
       return tab;
     }
   }
@@ -1066,14 +1106,14 @@ export async function fetchWindowTabs(
     throw new Error("Not connected to RepoPrompt");
   }
 
-  const manageWorkspacesToolName = resolveToolName(client.tools, "manage_workspaces");
-  if (!manageWorkspacesToolName) {
+  const bindContextToolName = resolveToolName(client.tools, "bind_context");
+  if (!bindContextToolName) {
     return [];
   }
 
-  const result = await client.callTool(manageWorkspacesToolName, {
-    action: "list_tabs",
-    ...bindingWindowArgs(windowId),
+  const result = await client.callTool(bindContextToolName, {
+    op: "list",
+    window_id: windowId,
   });
 
   if (result.isError) {
@@ -1086,7 +1126,7 @@ export async function fetchWindowTabs(
     return tabsFromJson;
   }
 
-  return parseTabList(extractTextContent(result.content));
+  return parseTabsFromBindContextText(extractTextContent(result.content));
 }
 
 async function selectTab(
@@ -1094,16 +1134,15 @@ async function selectTab(
   tabId: string,
   client: ReturnType<typeof getRpClient> = getRpClient()
 ): Promise<void> {
-  const manageWorkspacesToolName = resolveToolName(client.tools, "manage_workspaces");
-  if (!manageWorkspacesToolName) {
+  const bindContextToolName = resolveToolName(client.tools, "bind_context");
+  if (!bindContextToolName) {
     return;
   }
 
-  const result = await client.callTool(manageWorkspacesToolName, {
-    action: "select_tab",
-    tab: tabId,
-    focus: false,
-    ...bindingWindowArgs(windowId),
+  const result = await client.callTool(bindContextToolName, {
+    op: "bind",
+    window_id: windowId,
+    context_id: tabId,
   });
 
   if (result.isError) {
@@ -1290,7 +1329,7 @@ export async function ensureBindingHasTab(
   }
 
   if (!binding.tab || reuseSoleEmptyTab || recoverIfMissing) {
-    const reusableSafeTab = await findReusableSafeTab(liveTabs, client);
+    const reusableSafeTab = await findReusableSafeTab(binding.windowId, liveTabs, client);
     if (reusableSafeTab) {
       return await adoptTab(reusableSafeTab, true);
     }
@@ -1498,7 +1537,7 @@ export function getBindingArgs(): Record<string, unknown> {
   };
 
   if (currentBinding.tab) {
-    args._tabID = currentBinding.tab;
+    args.context_id = currentBinding.tab;
   }
 
   return args;

package/extensions/repoprompt-mcp/src/index.ts

@@ -813,7 +813,7 @@ export default function repopromptMcp(pi: ExtensionAPI) {
   function bindingArgsForAutoSelectionState(state: AutoSelectionEntryData): Record<string, unknown> {
     return {
       _windowID: state.windowId,
-      ...(state.tab ? { _tabID: state.tab } : {}),
+      ...(state.tab ? { context_id: state.tab } : {}),
     };
   }
 
@@ -1582,9 +1582,9 @@ export default function repopromptMcp(pi: ExtensionAPI) {
           try {
             await ensureTabScopedBinding(ctx, "RepoPrompt binding has no tab. Use /rp bind or /rp tab new first.");
 
-            const chatSendToolName = resolveToolName(client.tools, "chat_send");
-            if (!chatSendToolName) {
-              ctx.ui.notify("RepoPrompt tool 'chat_send' not available", "error");
+            const oracleSendToolName = resolveToolName(client.tools, "oracle_send");
+            if (!oracleSendToolName) {
+              ctx.ui.notify("RepoPrompt tool 'oracle_send' not available", "error");
               return;
             }
 
@@ -1598,7 +1598,7 @@ export default function repopromptMcp(pi: ExtensionAPI) {
             if (chatName) callArgs.chat_name = chatName;
             if (chatId) callArgs.chat_id = chatId;
 
-            const result = await client.callTool(chatSendToolName, callArgs);
+            const result = await client.callTool(oracleSendToolName, callArgs);
 
             const text = extractTextContent(result.content);
 
@@ -2541,7 +2541,15 @@ Mode priority: call > describe > search > windows > bind > status`,
     const userArgs = (params.args ?? {}) as Record<string, unknown>;
     const normalizedTool = normalizeToolName(tool.name);
 
-    if (getBinding() && !getBinding()?.tab && normalizedTool !== "manage_workspaces" && normalizedTool !== "list_windows") {
+    if (
+      getBinding() &&
+      !getBinding()?.tab &&
+      normalizedTool !== "manage_workspaces" &&
+      normalizedTool !== "list_windows" &&
+      normalizedTool !== "bind_context" &&
+      normalizedTool !== "agent_run" &&
+      normalizedTool !== "agent_manage"
+    ) {
       if (!ctx) {
         return {
           content: [{ type: "text" as const, text: "RepoPrompt binding has no tab. Re-bind with /rp bind before calling tab-scoped tools." }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-repoprompt-mcp",
-  "version": "0.5.5",
+  "version": "0.6.1",
   "description": "A token-efficient RepoPrompt integration for Pi with automated and branch-safe workspace management",
   "keywords": ["pi-package", "pi", "pi-coding-agent", "repoprompt", "mcp"],
   "license": "MIT",