@dungle-scrubs/tallow 0.8.23 → 0.8.25

package/packages/tallow-tui/node_modules/mime-types/index.js

@@ -0,0 +1,211 @@
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var db = require('mime-db')
+var extname = require('path').extname
+var mimeScore = require('./mimeScore')
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
+var TEXT_TYPE_REGEXP = /^text\//i
+
+/**
+ * Module exports.
+ * @public
+ */
+
+exports.charset = charset
+exports.charsets = { lookup: charset }
+exports.contentType = contentType
+exports.extension = extension
+exports.extensions = Object.create(null)
+exports.lookup = lookup
+exports.types = Object.create(null)
+exports._extensionConflicts = []
+
+// Populate the extensions/types maps
+populateMaps(exports.extensions, exports.types)
+
+/**
+ * Get the default charset for a MIME type.
+ *
+ * @param {string} type
+ * @return {false|string}
+ */
+
+function charset (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
+
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+  var mime = match && db[match[1].toLowerCase()]
+
+  if (mime && mime.charset) {
+    return mime.charset
+  }
+
+  // default text/* to utf-8
+  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+    return 'UTF-8'
+  }
+
+  return false
+}
+
+/**
+ * Create a full Content-Type header given a MIME type or extension.
+ *
+ * @param {string} str
+ * @return {false|string}
+ */
+
+function contentType (str) {
+  // TODO: should this even be in this module?
+  if (!str || typeof str !== 'string') {
+    return false
+  }
+
+  var mime = str.indexOf('/') === -1 ? exports.lookup(str) : str
+
+  if (!mime) {
+    return false
+  }
+
+  // TODO: use content-type or other module
+  if (mime.indexOf('charset') === -1) {
+    var charset = exports.charset(mime)
+    if (charset) mime += '; charset=' + charset.toLowerCase()
+  }
+
+  return mime
+}
+
+/**
+ * Get the default extension for a MIME type.
+ *
+ * @param {string} type
+ * @return {false|string}
+ */
+
+function extension (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
+
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+
+  // get extensions
+  var exts = match && exports.extensions[match[1].toLowerCase()]
+
+  if (!exts || !exts.length) {
+    return false
+  }
+
+  return exts[0]
+}
+
+/**
+ * Lookup the MIME type for a file path/extension.
+ *
+ * @param {string} path
+ * @return {false|string}
+ */
+
+function lookup (path) {
+  if (!path || typeof path !== 'string') {
+    return false
+  }
+
+  // get the extension ("ext" or ".ext" or full path)
+  var extension = extname('x.' + path)
+    .toLowerCase()
+    .slice(1)
+
+  if (!extension) {
+    return false
+  }
+
+  return exports.types[extension] || false
+}
+
+/**
+ * Populate the extensions and types maps.
+ * @private
+ */
+
+function populateMaps (extensions, types) {
+  Object.keys(db).forEach(function forEachMimeType (type) {
+    var mime = db[type]
+    var exts = mime.extensions
+
+    if (!exts || !exts.length) {
+      return
+    }
+
+    // mime -> extensions
+    extensions[type] = exts
+
+    // extension -> mime
+    for (var i = 0; i < exts.length; i++) {
+      var extension = exts[i]
+      types[extension] = _preferredType(extension, types[extension], type)
+
+      // DELETE (eventually): Capture extension->type maps that change as a
+      // result of switching to mime-score.  This is just to help make reviewing
+      // PR #119 easier, and can be removed once that PR is approved.
+      const legacyType = _preferredTypeLegacy(
+        extension,
+        types[extension],
+        type
+      )
+      if (legacyType !== types[extension]) {
+        exports._extensionConflicts.push([extension, legacyType, types[extension]])
+      }
+    }
+  })
+}
+
+// Resolve type conflict using mime-score
+function _preferredType (ext, type0, type1) {
+  var score0 = type0 ? mimeScore(type0, db[type0].source) : 0
+  var score1 = type1 ? mimeScore(type1, db[type1].source) : 0
+
+  return score0 > score1 ? type0 : type1
+}
+
+// Resolve type conflict using pre-mime-score logic
+function _preferredTypeLegacy (ext, type0, type1) {
+  var SOURCE_RANK = ['nginx', 'apache', undefined, 'iana']
+
+  var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0
+  var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0
+
+  if (
+    exports.types[extension] !== 'application/octet-stream' &&
+    (score0 > score1 ||
+      (score0 === score1 &&
+        exports.types[extension]?.slice(0, 12) === 'application/'))
+  ) {
+    return type0
+  }
+
+  return score0 > score1 ? type0 : type1
+}

package/packages/tallow-tui/node_modules/mime-types/mimeScore.js

@@ -0,0 +1,57 @@
+// 'mime-score' back-ported to CommonJS
+
+// Score RFC facets (see https://tools.ietf.org/html/rfc6838#section-3)
+var FACET_SCORES = {
+  'prs.': 100,
+  'x-': 200,
+  'x.': 300,
+  'vnd.': 400,
+  default: 900
+}
+
+// Score mime source (Logic originally from `jshttp/mime-types` module)
+var SOURCE_SCORES = {
+  nginx: 10,
+  apache: 20,
+  iana: 40,
+  default: 30 // definitions added by `jshttp/mime-db` project?
+}
+
+var TYPE_SCORES = {
+  // prefer application/xml over text/xml
+  // prefer application/rtf over text/rtf
+  application: 1,
+
+  // prefer font/woff over application/font-woff
+  font: 2,
+
+  // prefer video/mp4 over audio/mp4 over application/mp4
+  // See https://www.rfc-editor.org/rfc/rfc4337.html#section-2
+  audio: 2,
+  video: 3,
+
+  default: 0
+}
+
+/**
+ * Get each component of the score for a mime type.  The sum of these is the
+ * total score.  The higher the score, the more "official" the type.
+ */
+module.exports = function mimeScore (mimeType, source = 'default') {
+  if (mimeType === 'application/octet-stream') {
+    return 0
+  }
+
+  const [type, subtype] = mimeType.split('/')
+
+  const facet = subtype.replace(/(\.|x-).*/, '$1')
+
+  const facetScore = FACET_SCORES[facet] || FACET_SCORES.default
+  const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default
+  const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default
+
+  // All else being equal prefer shorter types
+  const lengthScore = 1 - mimeType.length / 100
+
+  return facetScore + sourceScore + typeScore + lengthScore
+}

package/packages/tallow-tui/node_modules/mime-types/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "mime-types",
+  "description": "The ultimate javascript content-type utility.",
+  "version": "3.0.2",
+  "contributors": [
+    "Douglas Christopher Wilson <doug@somethingdoug.com>",
+    "Jeremiah Senkpiel <fishrock123@rocketmail.com> (https://searchbeam.jit.su)",
+    "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "mime",
+    "types"
+  ],
+  "repository": "jshttp/mime-types",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/express"
+  },
+  "dependencies": {
+    "mime-db": "^1.54.0"
+  },
+  "devDependencies": {
+    "eslint": "8.33.0",
+    "eslint-config-standard": "14.1.1",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-markdown": "3.0.1",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "6.6.0",
+    "eslint-plugin-standard": "4.1.0",
+    "mocha": "10.8.2",
+    "nyc": "15.1.0"
+  },
+  "files": [
+    "HISTORY.md",
+    "LICENSE",
+    "index.js",
+    "mimeScore.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "mocha --reporter spec test/test.js",
+    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+    "test-cov": "nyc --reporter=html --reporter=text npm test"
+  }
+}

package/extensions/__integration__/plan-rejection-feedback.test.ts

@@ -1,272 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { ExtensionHarness } from "../../test-utils/extension-harness.js";
-import planModeExtension from "../plan-mode-tool/index.js";
-
-const PLAN_TEXT = [
-	"Plan:",
-	"1. Inspect tool failure paths in plan execution",
-	"2. Verify fallback behavior for blocked operations",
-	"3. Finalize recovery guidance for remaining step",
-].join("\n");
-
-interface ContextOptions {
-	readonly confirmResponse?: boolean;
-	readonly editorResponse?: string;
-	readonly hasUI: boolean;
-	readonly selectResponse?: string;
-}
-
-/**
- * Create a minimal extension context with configurable UI responses.
- *
- * @param options - Context and UI response options
- * @returns Extension context for direct event firing
- */
-function createContext(options: ContextOptions): ExtensionContext {
-	const theme = {
-		bg(_token: string, value: string) {
-			return value;
-		},
-		fg(_token: string, value: string) {
-			return value;
-		},
-		strikethrough(value: string) {
-			return value;
-		},
-	};
-
-	return {
-		abort: () => {},
-		compact: () => {},
-		cwd: process.cwd(),
-		getContextUsage: () => undefined,
-		getSystemPrompt: () => "",
-		hasPendingMessages: () => false,
-		hasUI: options.hasUI,
-		isIdle: () => true,
-		model: undefined,
-		modelRegistry: {
-			getApiKeyForProvider: async () => undefined,
-		} as never,
-		sessionManager: {
-			appendEntry: () => {},
-			getEntries: () => [],
-		} as never,
-		shutdown: () => {},
-		ui: {
-			async confirm() {
-				return options.confirmResponse ?? false;
-			},
-			async custom() {
-				return undefined as never;
-			},
-			async editor() {
-				return options.editorResponse;
-			},
-			async input() {
-				return undefined;
-			},
-			notify() {},
-			pasteToEditor() {},
-			async select() {
-				return options.selectResponse;
-			},
-			setEditorComponent() {},
-			setEditorText() {},
-			setFooter() {},
-			setHeader() {},
-			setStatus() {},
-			setTitle() {},
-			setToolsExpanded() {},
-			setWidget() {},
-			setWorkingMessage() {},
-			get theme() {
-				return theme as ExtensionContext["ui"]["theme"];
-			},
-			getAllThemes() {
-				return [];
-			},
-			getEditorText() {
-				return "";
-			},
-			getTheme() {
-				return undefined;
-			},
-			getToolsExpanded() {
-				return false;
-			},
-			setTheme() {
-				return { error: "Test stub", success: false };
-			},
-		} as ExtensionContext["ui"],
-	};
-}
-
-/**
- * Build an assistant message payload with a single text block.
- *
- * @param text - Assistant text content
- * @returns Assistant message payload
- */
-function assistantMessage(text: string): {
-	readonly content: readonly [{ readonly text: string; readonly type: "text" }];
-	readonly role: "assistant";
-} {
-	return {
-		content: [{ text, type: "text" }],
-		role: "assistant",
-	};
-}
-
-/**
- * Initialize plan execution mode with a 3-step plan and tracking enabled.
- *
- * @param harness - Extension harness with plan-mode extension loaded
- * @returns Promise that resolves once execution mode is active
- */
-async function initializeExecutionMode(harness: ExtensionHarness): Promise<void> {
-	harness.setFlag("plan", true);
-	await harness.fireEvent(
-		"session_start",
-		{ type: "session_start" },
-		createContext({ hasUI: true })
-	);
-	await harness.fireEvent(
-		"agent_end",
-		{ messages: [assistantMessage(PLAN_TEXT)] },
-		createContext({
-			hasUI: true,
-			selectResponse: "Execute the plan (track progress)",
-		})
-	);
-}
-
-/**
- * Fire a failed tool_result event using the documented test payload shape.
- *
- * @param harness - Extension harness instance
- * @param ctx - Extension context for the event
- * @returns Promise that resolves after handlers run
- */
-async function fireFailedToolResult(
-	harness: ExtensionHarness,
-	ctx: ExtensionContext
-): Promise<void> {
-	await harness.fireEvent(
-		"tool_result",
-		{
-			content: [{ text: "blocked", type: "text" }],
-			input: { command: "echo blocked" },
-			isError: true,
-			toolCallId: "tool-call-1",
-			toolName: "bash",
-		},
-		ctx
-	);
-}
-
-/**
- * Fire a turn_end event that marks a plan step as complete.
- *
- * @param harness - Extension harness instance
- * @param step - Step number to mark done
- * @returns Promise that resolves after handlers run
- */
-async function fireDoneStep(harness: ExtensionHarness, step: number): Promise<void> {
-	await harness.fireEvent(
-		"turn_end",
-		{ message: assistantMessage(`[DONE:${step}]`) },
-		createContext({ hasUI: true })
-	);
-}
-
-describe("Plan rejection feedback", () => {
-	it("ignores tool_result during execution when hasUI is false", async () => {
-		const harness = ExtensionHarness.create();
-		await harness.loadExtension(planModeExtension);
-		await initializeExecutionMode(harness);
-
-		await fireFailedToolResult(harness, createContext({ hasUI: false }));
-
-		expect(harness.sentUserMessages).toHaveLength(0);
-	});
-
-	it("sends steer guidance with Step 1 prefix when user confirms and provides guidance", async () => {
-		const harness = ExtensionHarness.create();
-		await harness.loadExtension(planModeExtension);
-		await initializeExecutionMode(harness);
-
-		await fireFailedToolResult(
-			harness,
-			createContext({
-				confirmResponse: true,
-				editorResponse: "Use a narrower inspection command and continue.",
-				hasUI: true,
-			})
-		);
-
-		expect(harness.sentUserMessages).toHaveLength(1);
-		const [message] = harness.sentUserMessages;
-		if (!message || typeof message.content !== "string") {
-			throw new Error("Expected one string user message");
-		}
-		expect(message.content.startsWith("[PLAN GUIDANCE — Step 1:")).toBe(true);
-		expect(message.options?.deliverAs).toBe("steer");
-	});
-
-	it("does not send guidance when user declines confirmation", async () => {
-		const harness = ExtensionHarness.create();
-		await harness.loadExtension(planModeExtension);
-		await initializeExecutionMode(harness);
-
-		await fireFailedToolResult(
-			harness,
-			createContext({
-				confirmResponse: false,
-				hasUI: true,
-			})
-		);
-
-		expect(harness.sentUserMessages).toHaveLength(0);
-	});
-
-	it("advances tracked step guidance to Step 3 and stops after all steps complete", async () => {
-		const harness = ExtensionHarness.create();
-		await harness.loadExtension(planModeExtension);
-		await initializeExecutionMode(harness);
-
-		await fireDoneStep(harness, 1);
-		await fireDoneStep(harness, 2);
-
-		await fireFailedToolResult(
-			harness,
-			createContext({
-				confirmResponse: true,
-				editorResponse: "Focus on the final verification sequence.",
-				hasUI: true,
-			})
-		);
-
-		expect(harness.sentUserMessages).toHaveLength(1);
-		const [stepThreeGuidance] = harness.sentUserMessages;
-		if (!stepThreeGuidance || typeof stepThreeGuidance.content !== "string") {
-			throw new Error("Expected one string user message");
-		}
-		expect(stepThreeGuidance.content.startsWith("[PLAN GUIDANCE — Step 3:")).toBe(true);
-		expect(stepThreeGuidance.options?.deliverAs).toBe("steer");
-
-		await fireDoneStep(harness, 3);
-
-		await fireFailedToolResult(
-			harness,
-			createContext({
-				confirmResponse: true,
-				editorResponse: "This should not be sent after completion.",
-				hasUI: true,
-			})
-		);
-
-		expect(harness.sentUserMessages).toHaveLength(1);
-	});
-});