panoma 0.1.8 → 0.9.0

package/app/node_modules/postcss/lib/stringifier.js

@@ -1,5 +1,21 @@
 'use strict'
 
+// Escapes sequences that could break out of an HTML <style> context.
+// Uses CSS unicode escaping (\3c = '<') which is valid CSS and parsed
+// correctly by all compliant CSS consumers.
+const STYLE_TAG = /(<)(\/?style\b)/gi
+const COMMENT_OPEN = /(<)(!--)/g
+
+// Characters that end an at-rule name, mirroring RE_AT_END in the tokenizer.
+// Params starting with anything else need a space to stay separate tokens.
+const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/
+
+function escapeHTMLInCSS(str) {
+  if (typeof str !== 'string') return str
+  if (!str.includes('<')) return str
+  return str.replace(STYLE_TAG, '\\3c $2').replace(COMMENT_OPEN, '\\3c $2')
+}
+
 const DEFAULT_RAW = {
   after: '\n',
   beforeClose: '\n',
@@ -19,26 +35,97 @@ function capitalize(str) {
   return str[0].toUpperCase() + str.slice(1)
 }
 
+function atruleStart(str, node) {
+  let name = '@' + node.name
+  let params = node.params ? str.rawValue(node, 'params') : ''
+  let afterName = node.raws.afterName
+
+  if (typeof afterName === 'undefined') {
+    afterName = params ? ' ' : ''
+  } else if (afterName === '' && params && !AT_NAME_END.test(params[0])) {
+    afterName = ' '
+  }
+
+  return name + afterName + params
+}
+
+// `*--x` is not a custom property: the parser checks the first token, and the
+// `*`/`_` hack prefix moves from `prop` into `before` only after that.
+function isCustomProperty(node) {
+  if (!node.prop.startsWith('--')) return false
+  let before = node.raws.before
+  return typeof before === 'undefined' || !/\S$/.test(before)
+}
+
+function pushBody(str, stack, node) {
+  let nodes = node.nodes
+  let last = nodes.length - 1
+  while (last > 0) {
+    if (nodes[last].type !== 'comment') break
+    last -= 1
+  }
+
+  let semicolon = str.raw(node, 'semicolon')
+  let isDocument = node.type === 'document'
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    let child = nodes[i]
+    let childSemicolon = last !== i || semicolon
+    // A childless at-rule or a custom property declaration that still has
+    // following siblings must be terminated. Without the semicolon those
+    // trailing comments are folded into the at-rule's prelude or the custom
+    // property's value and disappear when the output is re-parsed.
+    if (
+      !childSemicolon &&
+      i < nodes.length - 1 &&
+      ((child.type === 'atrule' && !child.nodes) ||
+        (child.type === 'decl' && isCustomProperty(child)))
+    ) {
+      childSemicolon = true
+    }
+    stack.push({
+      document: isDocument,
+      node: child,
+      semicolon: childSemicolon
+    })
+  }
+}
+
+function pushBlock(str, stack, node, start) {
+  let between = str.raw(node, 'between', 'beforeOpen')
+  str.builder(escapeHTMLInCSS(start + between) + '{', node, 'start')
+
+  let hasNodes = node.nodes && node.nodes.length
+  let close = () => {
+    let after = hasNodes
+      ? str.raw(node, 'after')
+      : str.raw(node, 'after', 'emptyBody')
+    if (after) str.builder(escapeHTMLInCSS(after))
+    str.builder('}', node, 'end')
+    if (node.type === 'rule' && node.raws.ownSemicolon) {
+      str.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end')
+    }
+  }
+
+  if (hasNodes) {
+    stack.push(close)
+    pushBody(str, stack, node)
+  } else {
+    close()
+  }
+}
+
 class Stringifier {
   constructor(builder) {
     this.builder = builder
   }
 
   atrule(node, semicolon) {
-    let name = '@' + node.name
-    let params = node.params ? this.rawValue(node, 'params') : ''
-
-    if (typeof node.raws.afterName !== 'undefined') {
-      name += node.raws.afterName
-    } else if (params) {
-      name += ' '
-    }
-
+    let start = atruleStart(this, node)
     if (node.nodes) {
-      this.block(node, name + params)
+      this.block(node, start)
     } else {
       let end = (node.raws.between || '') + (semicolon ? ';' : '')
-      this.builder(name + params + end, node)
+      this.builder(escapeHTMLInCSS(start + end), node)
     }
   }
 
@@ -73,7 +160,7 @@ class Stringifier {
 
   block(node, start) {
     let between = this.raw(node, 'between', 'beforeOpen')
-    this.builder(start + between + '{', node, 'start')
+    this.builder(escapeHTMLInCSS(start + between) + '{', node, 'start')
 
     let after
     if (node.nodes && node.nodes.length) {
@@ -83,42 +170,64 @@ class Stringifier {
       after = this.raw(node, 'after', 'emptyBody')
     }
 
-    if (after) this.builder(after)
+    if (after) this.builder(escapeHTMLInCSS(after))
     this.builder('}', node, 'end')
   }
 
   body(node) {
-    let last = node.nodes.length - 1
-    while (last > 0) {
-      if (node.nodes[last].type !== 'comment') break
-      last -= 1
-    }
+    // Rules and at-rules are expanded into an explicit stack instead of
+    // recursive `stringify()` calls to survive deeply nested trees.
+    // If a subclass changes the traversal methods, its children go
+    // through `stringify()` to keep the override in charge.
+    let proto = Stringifier.prototype
+    let expandable = ['atrule', 'block', 'body', 'rule', 'stringify'].every(
+      method => this[method] === proto[method]
+    )
+
+    let stack = []
+    pushBody(this, stack, node)
+
+    while (stack.length > 0) {
+      let entry = stack.pop()
+      if (typeof entry === 'function') {
+        entry()
+        continue
+      }
 
-    let semicolon = this.raw(node, 'semicolon')
-    for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i]
+      let child = entry.node
       let before = this.raw(child, 'before')
-      if (before) this.builder(before)
-      this.stringify(child, last !== i || semicolon)
+      if (before) {
+        this.builder(entry.document ? before : escapeHTMLInCSS(before))
+      }
+
+      if (expandable && child.type === 'rule') {
+        pushBlock(this, stack, child, this.rawValue(child, 'selector'))
+      } else if (expandable && child.type === 'atrule' && child.nodes) {
+        pushBlock(this, stack, child, atruleStart(this, child))
+      } else {
+        this.stringify(child, entry.semicolon)
+      }
     }
   }
 
   comment(node) {
     let left = this.raw(node, 'left', 'commentLeft')
     let right = this.raw(node, 'right', 'commentRight')
-    this.builder('/*' + left + node.text + right + '*/', node)
+    this.builder(escapeHTMLInCSS('/*' + left + node.text + right + '*/'), node)
   }
 
   decl(node, semicolon) {
+    let raws = node.raws
     let between = this.raw(node, 'between', 'colon')
+
     let string = node.prop + between + this.rawValue(node, 'value')
 
     if (node.important) {
-      string += node.raws.important || ' !important'
+      string += raws.important || ' !important'
     }
 
     if (semicolon) string += ';'
-    this.builder(string, node)
+    this.builder(escapeHTMLInCSS(string), node)
   }
 
   document(node) {
@@ -154,9 +263,9 @@ class Stringifier {
 
     // Detect style by other nodes
     let root = node.root()
-    if (!root.rawCache) root.rawCache = {}
-    if (typeof root.rawCache[detect] !== 'undefined') {
-      return root.rawCache[detect]
+    let cache = root.rawCache || (root.rawCache = {})
+    if (typeof cache[detect] !== 'undefined') {
+      return cache[detect]
     }
 
     if (detect === 'before' || detect === 'after') {
@@ -175,7 +284,7 @@ class Stringifier {
 
     if (typeof value === 'undefined') value = DEFAULT_RAW[detect]
 
-    root.rawCache[detect] = value
+    cache[detect] = value
     return value
   }
 
@@ -323,14 +432,21 @@ class Stringifier {
   }
 
   root(node) {
+    if (node.source && node.source.input.hasBOM) {
+      this.builder('\uFEFF', node, 'start')
+    }
     this.body(node)
-    if (node.raws.after) this.builder(node.raws.after)
+    if (node.raws.after) {
+      let after = node.raws.after
+      let isDocument = node.parent && node.parent.type === 'document'
+      this.builder(isDocument ? after : escapeHTMLInCSS(after))
+    }
   }
 
   rule(node) {
     this.block(node, this.rawValue(node, 'selector'))
     if (node.raws.ownSemicolon) {
-      this.builder(node.raws.ownSemicolon, node, 'end')
+      this.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end')
     }
   }
 

package/app/node_modules/postcss/lib/tokenize.js

@@ -29,13 +29,14 @@ module.exports = function tokenizer(input, options = {}) {
   let css = input.css.valueOf()
   let ignore = options.ignoreErrors
 
-  let code, next, quote, content, escape
-  let escaped, escapePos, prev, n, currentToken
+  let code, content, escape, next, quote
+  let currentToken, escaped, escapePos, n, prev
 
   let length = css.length
   let pos = 0
   let buffer = []
   let returned = []
+  let lastBadParen = -1
 
   function position() {
     return pos
@@ -127,11 +128,14 @@ module.exports = function tokenizer(input, options = {}) {
           currentToken = ['brackets', css.slice(pos, next + 1), pos, next]
 
           pos = next
+        } else if (pos <= lastBadParen) {
+          currentToken = ['(', '(', pos]
         } else {
           next = css.indexOf(')', pos + 1)
           content = css.slice(pos, next + 1)
 
           if (next === -1 || RE_BAD_BRACKET.test(content)) {
+            lastBadParen = next === -1 ? length : next
             currentToken = ['(', '(', pos]
           } else {
             currentToken = ['brackets', content, pos, next]

package/app/node_modules/postcss/lib/warning.js

@@ -1,11 +1,21 @@
 'use strict'
 
+let Container = require('./container')
+let { my } = require('./symbols')
+
 class Warning {
   constructor(text, opts = {}) {
     this.type = 'warning'
     this.text = text
 
     if (opts.node && opts.node.source) {
+      if (!opts.node[my]) {
+        // The node comes from another PostCSS copy in node_modules, so it does
+        // not have this copy’s methods. Container#normalize() rebuilds such
+        // nodes on insert, but a node passed straight to Result#warn() never
+        // goes through it.
+        Container.rebuild(opts.node)
+      }
       let range = opts.node.rangeBy(opts)
       this.line = range.start.line
       this.column = range.start.column

package/app/node_modules/postcss/package.json

@@ -1,14 +1,52 @@
 {
   "name": "postcss",
-  "version": "8.4.31",
+  "version": "8.5.28",
   "description": "Tool for transforming styles with JS plugins",
-  "engines": {
-    "node": "^10 || ^12 || >=14"
+  "keywords": [
+    "css",
+    "manipulation",
+    "parser",
+    "postcss",
+    "preprocessor",
+    "rework",
+    "source map",
+    "transform",
+    "transpiler"
+  ],
+  "homepage": "https://postcss.org/",
+  "bugs": {
+    "url": "https://github.com/postcss/postcss/issues"
   },
+  "license": "MIT",
+  "author": "Andrey Sitnik <andrey@sitnik.es>",
+  "repository": "postcss/postcss",
+  "funding": [
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/postcss/"
+    },
+    {
+      "type": "tidelift",
+      "url": "https://tidelift.com/funding/github/npm/postcss"
+    },
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/ai"
+    }
+  ],
+  "main": "./lib/postcss.js",
+  "browser": {
+    "./lib/terminal-highlight": false,
+    "source-map-js": false,
+    "path": false,
+    "url": false,
+    "fs": false
+  },
+  "types": "./lib/postcss.d.ts",
   "exports": {
     ".": {
-      "require": "./lib/postcss.js",
-      "import": "./lib/postcss.mjs"
+      "import": "./lib/postcss.mjs",
+      "require": "./lib/postcss.js"
     },
     "./lib/at-rule": "./lib/at-rule.js",
     "./lib/comment": "./lib/comment.js",
@@ -39,50 +77,12 @@
     "./lib/warning": "./lib/warning.js",
     "./package.json": "./package.json"
   },
-  "main": "./lib/postcss.js",
-  "types": "./lib/postcss.d.ts",
-  "keywords": [
-    "css",
-    "postcss",
-    "rework",
-    "preprocessor",
-    "parser",
-    "source map",
-    "transform",
-    "manipulation",
-    "transpiler"
-  ],
-  "funding": [
-    {
-      "type": "opencollective",
-      "url": "https://opencollective.com/postcss/"
-    },
-    {
-      "type": "tidelift",
-      "url": "https://tidelift.com/funding/github/npm/postcss"
-    },
-    {
-      "type": "github",
-      "url": "https://github.com/sponsors/ai"
-    }
-  ],
-  "author": "Andrey Sitnik <andrey@sitnik.ru>",
-  "license": "MIT",
-  "homepage": "https://postcss.org/",
-  "repository": "postcss/postcss",
-  "bugs": {
-    "url": "https://github.com/postcss/postcss/issues"
-  },
   "dependencies": {
-    "nanoid": "^3.3.6",
-    "picocolors": "^1.0.0",
-    "source-map-js": "^1.0.2"
+    "nanoid": "^3.3.18",
+    "picocolors": "^1.1.1",
+    "source-map-js": "^1.2.1"
   },
-  "browser": {
-    "./lib/terminal-highlight": false,
-    "source-map-js": false,
-    "path": false,
-    "url": false,
-    "fs": false
+  "engines": {
+    "node": "^10 || ^12 || >=14"
   }
 }

package/dist/ai-command-IRSVAWYU.js

@@ -0,0 +1,220 @@
+import {
+  NoCredentialError,
+  PROVIDERS,
+  complete,
+  configPath,
+  detectCliAgents,
+  findProvider,
+  maskKey,
+  providersByAuth,
+  readConfig,
+  resolveCredential,
+  updateConfig
+} from "./chunk-JY7ALFNX.js";
+import {
+  say
+} from "./chunk-P7ZGHSMO.js";
+import "./chunk-DITTKJ7U.js";
+import "./chunk-5EG7NRL4.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ai-command.ts
+import { createInterface } from "readline";
+import pc from "picocolors";
+async function aiCommand(parsed) {
+  const [, sub, ...rest] = parsed.positionals;
+  switch (sub) {
+    case void 0:
+    case "status":
+      return showStatus();
+    case "use":
+      return useProvider(rest[0], parsed.model);
+    case "key":
+      return storeKey(rest[0]);
+    case "ask":
+      return ask(rest.join(" "), parsed.provider);
+    default:
+      process.stderr.write(
+        pc.red(`${say("ai.unknownSub", { sub })}
+`) + `${say("ai.unknownSubHint")}
+`
+      );
+      return 1;
+  }
+}
+async function showStatus() {
+  const config = await readConfig();
+  const agents = await detectCliAgents(providersByAuth("cli"));
+  const out = process.stdout;
+  out.write(`
+${pc.bold(say("ai.activeProvider"))}
+`);
+  if (!config.provider) {
+    out.write(`  ${pc.yellow(say("ai.none"))}
+`);
+  } else {
+    try {
+      const credential = await resolveCredential(config.provider, config);
+      const source = say(`ai.source.${credential.source}`);
+      const detail = credential.apiKey ? say("ai.keyDetail", { masked: maskKey(credential.apiKey), source }) : source;
+      out.write(
+        `  ${pc.green("\u25CF")} ${credential.provider.name}  ${pc.dim(credential.model || say("ai.defaultModel"))}  ${pc.dim(detail)}
+`
+      );
+    } catch (error) {
+      const { detail, hint } = credentialProblem(error);
+      out.write(`  ${pc.red("\u25CF")} ${config.provider} \u2014 ${detail}
+`);
+      if (hint) out.write(`      ${pc.dim(hint)}
+`);
+    }
+  }
+  out.write(
+    `
+${pc.bold(say("ai.useSubscription"))}  ${pc.dim(say("ai.useSubscriptionNote"))}
+`
+  );
+  for (const { provider, installed, version, broken } of agents) {
+    const mark = installed ? pc.green("\u2713") : broken ? pc.yellow("!") : pc.dim("\xB7");
+    const state = installed ? pc.dim(version ?? say("ai.installed")) : broken ? pc.yellow(say("ai.agentBroken")) : pc.dim(say("ai.notInstalled"));
+    out.write(`  ${mark} ${provider.id.padEnd(12)} ${provider.name.padEnd(16)} ${state}
+`);
+  }
+  out.write(`
+${pc.bold(say("ai.withKey"))}
+`);
+  for (const provider of providersByAuth("api-key")) {
+    const fromEnv = (provider.apiKeyEnvVars ?? []).find((name) => process.env[name]);
+    const stored = config.keys?.[provider.id];
+    const mark = fromEnv || stored ? pc.green("\u2713") : pc.dim("\xB7");
+    const state = fromEnv ? pc.dim(say("ai.fromEnv", { name: fromEnv })) : stored ? pc.dim(say("ai.storedKey", { masked: maskKey(stored) })) : pc.dim(provider.signupUrl ?? "");
+    out.write(`  ${mark} ${provider.id.padEnd(12)} ${provider.name.padEnd(16)} ${state}
+`);
+  }
+  out.write(`
+${pc.dim(say("ai.configAt", { path: configPath() }))}
+`);
+  out.write(
+    `${pc.dim(say("ai.onDemand"))}
+
+`
+  );
+  return 0;
+}
+async function useProvider(id, model) {
+  if (!id) {
+    process.stderr.write(
+      pc.red(`${say("ai.missingProvider")}
+`) + `${say("ai.available", { list: PROVIDERS.map((p) => p.id).join(", ") })}
+`
+    );
+    return 1;
+  }
+  const provider = findProvider(id);
+  if (!provider) {
+    process.stderr.write(pc.red(`${say("ai.unknownProvider", { id })}
+`));
+    return 1;
+  }
+  const next = await updateConfig((config) => {
+    const updated = { ...config, provider: provider.id };
+    if (model) updated.model = model;
+    else if (config.provider !== provider.id) delete updated.model;
+    return updated;
+  });
+  process.stdout.write(
+    `${pc.green("\u2713")} ${say("ai.chosenProvider", { name: provider.name })}` + say("ai.chosenModel", {
+      model: next.model ?? provider.defaultModel ?? say("ai.sessionModel")
+    }) + "\n"
+  );
+  try {
+    await resolveCredential(provider.id, next);
+  } catch (error) {
+    process.stdout.write(`${pc.yellow("!")} ${error.message}
+`);
+  }
+  return 0;
+}
+async function storeKey(id) {
+  const provider = id ? findProvider(id) : void 0;
+  if (!provider || provider.auth !== "api-key") {
+    process.stderr.write(
+      pc.red(`${say("ai.keyUsage")}
+`) + `${say("ai.keyProviders", { list: providersByAuth("api-key").map((p) => p.id).join(", ") })}
+`
+    );
+    return 1;
+  }
+  process.stdout.write(
+    `${say("ai.pasteKey", { name: provider.name })} ${pc.dim(say("ai.pasteKeyNote"))}
+> `
+  );
+  const key = await readSecret();
+  if (!key) {
+    process.stderr.write(pc.red(`
+${say("ai.keyEmpty")}
+`));
+    return 1;
+  }
+  const { saveKey } = await import("./dist-NQIOBJFO.js");
+  await saveKey(provider.id, key);
+  process.stdout.write(
+    `
+${pc.green("\u2713")} ${say("ai.saved", { masked: maskKey(key), name: provider.name, path: configPath() })}
+` + pc.dim(`  ${say("ai.notEncrypted")}
+`)
+  );
+  return 0;
+}
+function readSecret() {
+  return new Promise((resolve) => {
+    const input = process.stdin;
+    const rl = createInterface({ input, output: process.stdout, terminal: true });
+    const wasRaw = input.isTTY;
+    if (wasRaw) {
+      rl._writeToOutput = () => {
+      };
+    }
+    rl.question("", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function ask(prompt, provider) {
+  if (!prompt) {
+    process.stderr.write(pc.red(`${say("ai.askUsage")}
+`));
+    return 1;
+  }
+  try {
+    const started = Date.now();
+    const result = await complete({ prompt, provider, maxTokens: 1024 });
+    const seconds = ((Date.now() - started) / 1e3).toFixed(1);
+    process.stdout.write(`
+${result.text}
+`);
+    process.stdout.write(
+      pc.dim(
+        `
+\u2014 ${result.provider} \xB7 ${result.model} \xB7 ${seconds}s` + (result.usage ? ` \xB7 ${result.usage.input}\u2192${result.usage.output} tokens` : "") + "\n"
+      )
+    );
+    return 0;
+  } catch (error) {
+    process.stderr.write(pc.red(`${error.message}
+`));
+    return 1;
+  }
+}
+function credentialProblem(error) {
+  if (error instanceof NoCredentialError) {
+    const { provider } = error;
+    const hint = provider.auth === "cli" ? say("ai.hintCli", { name: provider.name, command: provider.command ?? provider.id }) : provider.auth === "oauth" ? say("ai.hintOauth", { name: provider.name, id: provider.id }) : say("ai.hintKey", { id: provider.id, url: provider.signupUrl ?? "" });
+    return { detail: say("ai.noCredential", { name: provider.name }), hint };
+  }
+  return { detail: error.message ?? String(error) };
+}
+export {
+  aiCommand
+};

package/dist/apps-FI2Q2CFP.js

@@ -0,0 +1,17 @@
+import {
+  appsCommand,
+  appsFetch,
+  confirmApps,
+  followAppJob
+} from "./chunk-BCHIG2AU.js";
+import "./chunk-YQOQAFTY.js";
+import "./chunk-P7ZGHSMO.js";
+import "./chunk-DITTKJ7U.js";
+import "./chunk-5EG7NRL4.js";
+import "./chunk-MLKGABMK.js";
+export {
+  appsCommand,
+  appsFetch,
+  confirmApps,
+  followAppJob
+};