pi-code 1.0.4 → 1.0.6

package/extensions/internal/project-root.ts

@@ -0,0 +1,78 @@
+/**
+ * Upward search for project configuration, shared across extensions.
+ *
+ * Claude anchors project config (.claude/*, .mcp.json, CLAUDE.local.md) at the
+ * project root, so a session started in a subdirectory must still find it. The
+ * walk runs from cwd up to the repository root and no further: without the bound,
+ * config planted in a world-writable ancestor such as /tmp would be offered to
+ * every session beneath it. With no project marker the extent is unknown, so only
+ * cwd is considered. The project-approval walk uses the same markers, so whatever
+ * these find is exactly what that walk gated.
+ */
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+/** Project root markers ending the walk. `.git` is a file in worktrees and submodules. */
+export const ROOT_MARKERS = ['.git', 'package.json']
+
+/** Project root at or above `from`, or undefined when no marker is found. */
+export function repoRoot(from: string): string | undefined {
+  let currentDir = from
+  while (true) {
+    if (ROOT_MARKERS.some((marker) => fs.existsSync(path.join(currentDir, marker)))) return currentDir
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) return undefined
+    currentDir = parentDir
+  }
+}
+
+function statOf(target: string): fs.Stats | null {
+  try {
+    return fs.statSync(target)
+  } catch {
+    return null
+  }
+}
+
+function findNearest(cwd: string, relative: string, wantDir: boolean): string | null {
+  const boundary = repoRoot(cwd) ?? cwd
+  let currentDir = cwd
+  while (true) {
+    const candidate = path.join(currentDir, relative)
+    const stat = statOf(candidate)
+    if (stat && (wantDir ? stat.isDirectory() : stat.isFile())) return candidate
+
+    if (currentDir === boundary) return null
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) return null
+    currentDir = parentDir
+  }
+}
+
+/** Nearest `relative` directory at or above `cwd`, stopping at the repository root. */
+export function findNearestDir(cwd: string, relative: string): string | null {
+  return findNearest(cwd, relative, true)
+}
+
+/** Nearest `relative` file at or above `cwd`, stopping at the repository root. */
+export function findNearestFile(cwd: string, relative: string): string | null {
+  return findNearest(cwd, relative, false)
+}
+
+/** Every `relative` file between the repository root and cwd, ordered root first,
+ * matching Claude's root-down ordering for hierarchy-loaded context. */
+export function ancestorFiles(cwd: string, relative: string): string[] {
+  const boundary = repoRoot(cwd) ?? cwd
+  const found: string[] = []
+  let currentDir = cwd
+  while (true) {
+    const candidate = path.join(currentDir, relative)
+    if (statOf(candidate)?.isFile()) found.push(candidate)
+    if (currentDir === boundary) break
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) break
+    currentDir = parentDir
+  }
+  return found.reverse()
+}

package/extensions/internal/shell-split.ts

@@ -0,0 +1,65 @@
+/**
+ * Quote-aware splitting of a shell command into its top-level segments.
+ *
+ * Shared by plan mode's bash guard and the commands extension's allowed-tools
+ * scope enforcement: both vet each subcommand on its own, and both refuse to
+ * guess when the shell could be hiding another command.
+ */
+
+// The shell can hide an arbitrary command inside any of these, so callers refuse
+// such a command outright rather than parse it.
+const SUBSTITUTION = /\$\(|`|<\(|>\(/
+
+export const hasSubstitution = (command: string): boolean => SUBSTITUTION.test(command)
+
+/** Length of the separator at `i`, or 0 when there is none. */
+function separatorAt(command: string, i: number): number {
+  const pair = command.slice(i, i + 2)
+  if (pair === '&&' || pair === '||' || pair === '|&') return 2
+  const ch = command[i]
+  return ch === ';' || ch === '|' || ch === '&' || ch === '\n' ? 1 : 0
+}
+
+/**
+ * Split on the shell separators Claude Code documents (`&&`, `||`, `;`, `|`, `|&`, `&`,
+ * newline) so every subcommand is checked on its own, ignoring separators inside quotes:
+ * `grep 'a|b'` is one read, not a pipe. Returns nothing on an unbalanced quote, which
+ * fails the caller closed rather than guessing at the intended split.
+ *
+ * A shell AST would be exact; this is the honest approximation for a quoting-only concern.
+ */
+export function splitSegments(command: string): string[] {
+  const segments: string[] = []
+  let current = ''
+  let quote: "'" | '"' | undefined
+
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i]
+    if (quote !== undefined) {
+      current += ch
+      if (ch === quote) quote = undefined
+      continue
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch
+      current += ch
+      continue
+    }
+    if (ch === '\\' && i + 1 < command.length) {
+      current += ch + command[++i]
+      continue
+    }
+    const separator = separatorAt(command, i)
+    if (separator > 0) {
+      segments.push(current)
+      current = ''
+      i += separator - 1
+      continue
+    }
+    current += ch
+  }
+
+  if (quote !== undefined) return []
+  segments.push(current)
+  return segments.map((segment) => segment.trim()).filter(Boolean)
+}

package/extensions/internal/strip-comments.ts

@@ -0,0 +1,100 @@
+/**
+ * Block-level HTML comment stripping for context and rule files.
+ *
+ * Claude Code strips block-level HTML comments (`<!-- maintainer notes -->`)
+ * from CLAUDE.md files before injection, while preserving comments inside code
+ * blocks. "Block-level" is read as whole-line-anchored: a comment counts only
+ * when it starts a line (after optional indentation) and nothing but comments
+ * and whitespace occupy the line(s) it spans; those lines are removed entirely,
+ * a multi-line comment with every line it covers. A comment sharing a line with
+ * real content is inline prose and stays verbatim, as does anything inside a
+ * fenced code block (backtick or tilde).
+ */
+
+/** The fence a line opens or closes, if any; mirrors context-imports. */
+export function fenceMarker(lineStart: string): string | null {
+  if (lineStart.startsWith('```')) return '`'
+  if (lineStart.startsWith('~~~')) return '~'
+  return null
+}
+
+/** Length of the fence run starting `lineStart`, a run of `marker` characters. */
+function fenceLength(lineStart: string, marker: string): number {
+  let length = 0
+  while (length < lineStart.length && lineStart[length] === marker) length++
+  return length
+}
+
+// CommonMark closes a fenced block only with a fence of the same character that
+// is at least as long as the opener, so both are tracked: a shorter same-char
+// fence line (the classic 3-backtick block quoted inside a 4-backtick one) is
+// content, not a closer.
+interface Fence {
+  marker: string
+  length: number
+}
+
+/** The fence state after a line, plus whether the line is fenced code (opener,
+ * body, or closer) and so emitted verbatim rather than scanned for comments. */
+function stepFence(fence: Fence | null, trimmed: string, marker: string | null): { fence: Fence | null; fenced: boolean } {
+  if (marker !== null && fence === null) {
+    return { fence: { marker, length: fenceLength(trimmed, marker) }, fenced: true }
+  }
+  if (fence !== null) {
+    const closes = marker === fence.marker && fenceLength(trimmed, marker) >= fence.length
+    return { fence: closes ? null : fence, fenced: true } // closer included: comments are content, not maintainer notes
+  }
+  return { fence, fenced: false }
+}
+
+/** Advance a line while inside an open multi-line comment. Emits any content that
+ * trails the closer onto its own line; returns whether the comment stays open. */
+function continueOpenComment(out: string[], line: string): boolean {
+  const close = line.indexOf('-->')
+  if (close === -1) return true // still inside the comment: the line goes with it
+  const rest = line.slice(close + 3)
+  // Content trailing the closer keeps its line; a bare closer line is dropped.
+  if (rest.trim().length > 0) out.push(rest.trimStart())
+  return false
+}
+
+/** Fold line-starting HTML comments off `trimmed`; several may share one line.
+ * `allComment` means the line held nothing but comments and whitespace, so it is
+ * dropped; `opensBlock` means the last comment opened a multi-line block. */
+function consumeLineComments(trimmed: string): { allComment: boolean; opensBlock: boolean } {
+  let rest = trimmed
+  let sawComment = false
+  while (rest.startsWith('<!--')) {
+    sawComment = true
+    const close = rest.indexOf('-->')
+    if (close === -1) return { allComment: true, opensBlock: true } // opens a multi-line comment
+    rest = rest.slice(close + 3).trimStart()
+  }
+  return { allComment: sawComment && rest.length === 0, opensBlock: false }
+}
+
+/** Remove whole-line HTML comments, keeping fenced code and inline comments. */
+export function stripBlockComments(text: string): string {
+  const out: string[] = []
+  let fence: Fence | null = null
+  let inComment = false
+  for (const line of text.split('\n')) {
+    if (inComment) {
+      inComment = continueOpenComment(out, line)
+      continue
+    }
+    const trimmed = line.trimStart()
+    const step = stepFence(fence, trimmed, fenceMarker(trimmed))
+    fence = step.fence
+    if (step.fenced) {
+      out.push(line)
+      continue
+    }
+    const { allComment, opensBlock } = consumeLineComments(trimmed)
+    if (opensBlock) inComment = true
+    if (allComment) continue // the whole line was comment
+    // No comment, or a line-starting comment followed by content: inline, verbatim.
+    out.push(line)
+  }
+  return out.join('\n')
+}

package/extensions/internal/web-transport.ts

@@ -32,7 +32,9 @@ export function httpFetch(url: URL, opts: TransportOptions): Promise<Response> {
       url,
       {
         method: 'GET',
-        headers: { 'User-Agent': opts.userAgent },
+        // Prefer markdown, as Claude's WebFetch does, so a content-negotiating
+        // server can return markdown directly and skip the lossy HTML conversion.
+        headers: { 'User-Agent': opts.userAgent, Accept: 'text/markdown, text/html;q=0.9, */*;q=0.8' },
         signal: opts.signal,
         lookup: opts.lookup,
         // servername is left to default to url.hostname, so SNI and certificate