@davait/aipictury 1.9.2

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@davait/aipictury",
+  "version": "1.9.2",
+  "description": "The AIPictury agent in a terminal: the VS Code extension's agent, on your own GPU server, signed in to your AIPictury account.",
+  "bin": {
+    "aipictury": "main.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "prepack": "node pack.mjs",
+    "postpack": "node pack.mjs --clean",
+    "lint": "../vscode/node_modules/.bin/eslint . --max-warnings=0",
+    "test": "node test/cli-check.mjs"
+  },
+  "author": "Davait, Inc.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "homepage": "https://aipictury.com",
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "coding",
+    "local",
+    "gpu",
+    "aipictury"
+  ],
+  "files": [
+    "main.js",
+    "terminal.js",
+    "vscode-shim.js",
+    "ext/",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "playwright-core": "^1.63.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/terminal.js

@@ -0,0 +1,124 @@
+'use strict'
+// The terminal's own pieces for the interactive mode: colours, a spinner while the agent works,
+// the answer's Markdown drawn as it streams, and completion for /commands and @files.
+// Copyright © 2026 Davait, Inc. All rights reserved.
+
+const tty = !!process.stdout.isTTY
+const paint = (code) => (t) => (tty ? `\x1b[${code}m${t}\x1b[0m` : String(t))
+const dim = paint(2); const bold = paint(1); const italic = paint(3); const red = paint(31); const green = paint(32)
+const yellow = paint(33); const cyan = paint(36); const magenta = paint(35)
+
+// What a line looks like on screen, without its colours: for fitting it to the terminal.
+const visible = (s) => String(s).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '') // eslint-disable-line no-control-regex
+
+/** `code`, **bold**, *italic*, [text](url) — inside a line, code spans left as they are. */
+function inline(line) {
+  return line.split(/(`[^`]+`)/).map((part) => {
+    if (/^`[^`]+`$/.test(part)) return cyan(part.slice(1, -1))
+    return part
+      .replace(/\*\*([^*]+)\*\*/g, (_, t) => bold(t))
+      .replace(/(^|[\s(])\*([^*\s][^*]*)\*(?=[\s).,;:!?]|$)/g, (_, pre, t) => `${pre}${italic(t)}`)
+      .replace(/(^|[\s(])_([^_\s][^_]*)_(?=[\s).,;:!?]|$)/g, (_, pre, t) => `${pre}${italic(t)}`)
+      .replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, t, url) => `${t} ${dim(`(${url})`)}`)
+  }).join('')
+}
+
+/** One finished line of Markdown, for the terminal. `state` carries whether it is inside a fence. */
+function markdownLine(line, state) {
+  if (/^\s*(```|~~~)/.test(line)) { state.code = !state.code; return dim(line) }
+  if (state.code) return `${dim('│')} ${line}`
+  let m
+  if ((m = /^(#{1,6})\s+(.*)$/.exec(line))) return m[1].length <= 2 ? bold(inline(m[2])) : bold(dim(inline(m[2])))
+  if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) return dim('─'.repeat(40))
+  if ((m = /^(\s*)>\s?(.*)$/.exec(line))) return `${m[1]}${dim('│')} ${dim(inline(m[2]))}`
+  if ((m = /^(\s*)[-*+]\s+\[([ xX])\]\s+(.*)$/.exec(line))) return `${m[1]}${m[2] === ' ' ? '☐' : '☑'} ${inline(m[3])}`
+  if ((m = /^(\s*)[-*+]\s+(.*)$/.exec(line))) return `${m[1]}${dim('•')} ${inline(m[2])}`
+  if (/^\s*\|.*\|\s*$/.test(line)) return /^\s*\|[\s:|-]+\|\s*$/.test(line) ? dim(line) : inline(line)
+  return inline(line)
+}
+
+/**
+ * The answer as it streams: each piece written at once, and each line drawn again as Markdown
+ * once it is whole (when it still fits on one terminal row; a longer one stays as it came).
+ */
+class MarkdownStream {
+  constructor(out = process.stdout) { this.out = out; this.state = { code: false }; this.line = '' }
+
+  push(text) {
+    const parts = String(text).split('\n')
+    parts.forEach((part, i) => {
+      if (i > 0) this.finish('\n')
+      if (part) { this.out.write(part); this.line += part }
+    })
+  }
+
+  finish(end = '') {
+    const width = this.out.columns || 80
+    const drawn = markdownLine(this.line, this.state)
+    if (tty && this.line && visible(this.line).length < width - 1) this.out.write(`\r\x1b[K${drawn}`)
+    this.out.write(end)
+    this.line = ''
+  }
+
+  end() { if (this.line) this.finish(); this.state = { code: false } }
+}
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+/** "⠹ working · 12s · esc to stop", kept on the line below the output while the agent works. */
+class Spinner {
+  constructor({ out = process.stdout, busyTyping = () => false } = {}) {
+    this.out = out
+    this.busyTyping = busyTyping
+    this.on = tty
+    this.timer = null
+    this.frame = 0
+    this.shown = false
+  }
+
+  start(label = 'working') {
+    if (!this.on) return
+    this.label = label
+    this.since ||= Date.now()
+    if (!this.timer) this.timer = setInterval(() => this.draw(), 100)
+    this.draw()
+  }
+
+  draw() {
+    // Someone typing ahead owns the line: the spinner waits.
+    if (this.busyTyping()) { this.clear(); return }
+    const secs = Math.round((Date.now() - this.since) / 1000)
+    this.out.write(`\r\x1b[K${magenta(FRAMES[this.frame++ % FRAMES.length])} ${dim(`${this.label} · ${secs}s · esc to stop`)}`)
+    this.shown = true
+  }
+
+  clear() { if (this.shown) { this.out.write('\r\x1b[K'); this.shown = false } }
+
+  /** Hidden for output; start() brings it back with the same clock. */
+  pause() { if (this.timer) { clearInterval(this.timer); this.timer = null } this.clear() }
+
+  stop() { this.pause(); this.since = 0 }
+}
+
+/**
+ * Completion for the prompt: /commands at the start of a line, @files anywhere.
+ * `commands()` lists the names; `files(query)` resolves to paths (the extension's own fuzzy search).
+ */
+function completer({ commands, files }) {
+  return (line, done) => {
+    const slash = /^\/([\w:.-]*)$/.exec(line)
+    if (slash) {
+      const names = commands().map((n) => `/${n}`)
+      const hits = names.filter((n) => n.startsWith(line))
+      done(null, [hits.length ? hits : names, line])
+      return
+    }
+    const at = /(?:^|\s)(@[^\s@]*)$/.exec(line)
+    if (!at) { done(null, [[], line]); return }
+    Promise.resolve(files(at[1].slice(1))).then((found) => {
+      done(null, [found.slice(0, 30).map((f) => `@${f}`), at[1]])
+    }, () => done(null, [[], line]))
+  }
+}
+
+module.exports = { tty, dim, bold, italic, red, green, yellow, cyan, magenta, visible, inline, markdownLine, MarkdownStream, Spinner, completer }

package/vscode-shim.js

@@ -0,0 +1,231 @@
+'use strict'
+// The few VS Code APIs the agent's code uses, for the terminal: the CLI runs the extension's own
+// agent (agent.js, tools, rules, hooks, MCP, skills, sandbox) with this module standing in for
+// `vscode`. Files are the disk, the workspace is the folder the CLI was started in, settings come
+// from ~/.aipictury/cli.json (and the extension's defaults), the log is a file. What only VS
+// Code has — language servers, open editors, notebooks, its commands — is absent, and the CLI
+// does not offer the tools that need it.
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+const state = {
+  root: process.cwd(),
+  defaults: {},                 // "aipictury.x" → default, from the extension's package.json
+  settings: {},                 // "aipictury.x" → value, from ~/.aipictury/cli.json and flags
+  settingsFile: null,
+  logFile: null,
+}
+
+class Uri {
+  constructor(scheme, p, extra = {}) {
+    this.scheme = scheme
+    this.path = p
+    this.fsPath = scheme === 'file' ? path.normalize(p) : p
+    Object.assign(this, extra)
+  }
+
+  static file(p) { return new Uri('file', path.resolve(p)) }
+
+  static parse(text) {
+    try {
+      const u = new URL(text)
+      if (u.protocol === 'file:') return Uri.file(decodeURIComponent(u.pathname))
+      return new Uri(u.protocol.slice(0, -1), u.pathname, { authority: u.host, query: u.search.slice(1), fragment: u.hash.slice(1), href: text })
+    } catch { return Uri.file(text) }
+  }
+
+  static joinPath(base, ...parts) { return Uri.file(path.join(base.fsPath, ...parts)) }
+
+  with(change = {}) { return change.path ? Uri.file(change.path) : this }
+
+  toString() { return this.scheme === 'file' ? `file://${this.fsPath}` : this.href || `${this.scheme}:${this.path}` }
+}
+
+const FileType = { Unknown: 0, File: 1, Directory: 2, SymbolicLink: 64 }
+const asUri = (u) => (typeof u === 'string' ? Uri.file(u) : u)
+
+const fileSystem = {
+  async readFile(uri) { return new Uint8Array(await fs.promises.readFile(asUri(uri).fsPath)) },
+  async writeFile(uri, data) {
+    const p = asUri(uri).fsPath
+    await fs.promises.mkdir(path.dirname(p), { recursive: true })
+    await fs.promises.writeFile(p, data)
+  },
+  async stat(uri) {
+    const s = await fs.promises.stat(asUri(uri).fsPath)
+    return { type: s.isDirectory() ? FileType.Directory : FileType.File, size: s.size, mtime: s.mtimeMs, ctime: s.ctimeMs }
+  },
+  async readDirectory(uri) {
+    const list = await fs.promises.readdir(asUri(uri).fsPath, { withFileTypes: true })
+    return list.map((d) => [d.name, d.isDirectory() ? FileType.Directory : d.isSymbolicLink() ? FileType.SymbolicLink : FileType.File])
+  },
+  async createDirectory(uri) { await fs.promises.mkdir(asUri(uri).fsPath, { recursive: true }) },
+  async delete(uri, { recursive = false } = {}) { await fs.promises.rm(asUri(uri).fsPath, { recursive, force: false }) },
+  async copy(from, to, { overwrite = false } = {}) {
+    await fs.promises.cp(asUri(from).fsPath, asUri(to).fsPath, { recursive: true, force: overwrite, errorOnExist: !overwrite })
+  },
+  async rename(from, to, { overwrite = false } = {}) {
+    if (!overwrite && fs.existsSync(asUri(to).fsPath)) throw new Error(`${asUri(to).fsPath} exists`)
+    await fs.promises.rename(asUri(from).fsPath, asUri(to).fsPath)
+  },
+}
+
+class RelativePattern {
+  constructor(base, pattern) {
+    this.baseUri = typeof base === 'string' ? Uri.file(base) : base.uri || base
+    this.base = this.baseUri.fsPath
+    this.pattern = pattern
+  }
+}
+
+/** A glob as a regular expression: ** any depth, * one segment, ? one character, {a,b}. */
+function globRe(glob) {
+  let out = ''
+  for (let i = 0; i < glob.length; i += 1) {
+    const c = glob[i]
+    if (c === '*' && glob[i + 1] === '*') { i += 1; if (glob[i + 1] === '/') { i += 1; out += '(?:.*/)?' } else out += '.*' } else if (c === '*') out += '[^/]*'
+    else if (c === '?') out += '[^/]'
+    else if (c === '{') { const end = glob.indexOf('}', i); out += `(?:${glob.slice(i + 1, end).split(',').map((p) => p.replace(/[.+^$()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*')).join('|')})`; i = end } else out += c.replace(/[.+^$()|[\]\\]/g, '\\$&')
+  }
+  return new RegExp(`^${out}$`)
+}
+
+/** Files under the workspace (or a pattern's base) matching a glob, as VS Code's findFiles. */
+async function findFiles(include, exclude, max = 10_000) {
+  const base = include instanceof RelativePattern ? include.base : state.root
+  const match = globRe(include instanceof RelativePattern ? include.pattern : include)
+  const skip = exclude ? globRe(exclude instanceof RelativePattern ? exclude.pattern : exclude) : null
+  const out = []
+  const walk = async (dir) => {
+    let list
+    try { list = await fs.promises.readdir(dir, { withFileTypes: true }) } catch { return }
+    for (const d of list) {
+      if (out.length >= max) return
+      const full = path.join(dir, d.name)
+      const rel = path.relative(base, full).split(path.sep).join('/')
+      if (d.name === '.git' || (skip && (skip.test(rel) || skip.test(`${rel}/`) || skip.test(`${rel}/x`)))) continue
+      if (d.isDirectory()) await walk(full)
+      else if (match.test(rel)) out.push(Uri.file(full))
+    }
+  }
+  await walk(base)
+  return out
+}
+
+function getConfiguration(section) {
+  const key = (k) => (section ? `${section}.${k}` : k)
+  return {
+    get(k, fallback) {
+      const full = key(k)
+      if (full in state.settings) return state.settings[full]
+      if (full in state.defaults) return state.defaults[full]
+      // An object setting asked for by its section ("sandbox" → sandbox.enabled…).
+      const prefix = `${full}.`
+      const nested = Object.keys({ ...state.defaults, ...state.settings }).filter((n) => n.startsWith(prefix))
+      if (nested.length) return Object.fromEntries(nested.map((n) => [n.slice(prefix.length), n in state.settings ? state.settings[n] : state.defaults[n]]))
+      return fallback
+    },
+    has(k) { return key(k) in state.settings || key(k) in state.defaults },
+    inspect(k) { return { key: key(k), defaultValue: state.defaults[key(k)], globalValue: state.settings[key(k)] } },
+    async update(k, value) {
+      const full = key(k)
+      if (value === undefined) delete state.settings[full]
+      else state.settings[full] = value
+      if (state.settingsFile) {
+        let saved = {}
+        try { saved = JSON.parse(fs.readFileSync(state.settingsFile, 'utf8')) } catch { /* none yet */ }
+        if (value === undefined) delete saved[full]; else saved[full] = value
+        fs.mkdirSync(path.dirname(state.settingsFile), { recursive: true })
+        fs.writeFileSync(state.settingsFile, `${JSON.stringify(saved, null, 2)}\n`)
+      }
+    },
+  }
+}
+
+const noEvent = () => ({ dispose() {} })
+
+class EventEmitter {
+  constructor() { this.listeners = new Set(); this.event = (fn) => { this.listeners.add(fn); return { dispose: () => this.listeners.delete(fn) } } }
+  fire(value) { for (const fn of this.listeners) fn(value) }
+  dispose() { this.listeners.clear() }
+}
+
+function outputChannel() {
+  const write = (level) => (text) => {
+    if (!state.logFile) return
+    try {
+      fs.mkdirSync(path.dirname(state.logFile), { recursive: true })
+      fs.appendFileSync(state.logFile, `${new Date().toISOString()} [${level}] ${text}\n`)
+    } catch { /* a log is never worth failing for */ }
+  }
+  return { info: write('info'), warn: write('warn'), error: write('error'), appendLine: write('info'), append: write('info'), show() {}, clear() {}, dispose() {} }
+}
+
+/** Where an installed VS Code keeps its files: its ripgrep is used for search, as in the editor. */
+function appRoot() {
+  const candidates = {
+    darwin: ['/Applications/Visual Studio Code.app/Contents/Resources/app', path.join(os.homedir(), 'Applications/Visual Studio Code.app/Contents/Resources/app')],
+    linux: ['/usr/share/code/resources/app', '/opt/visual-studio-code/resources/app', '/snap/code/current/usr/share/code/resources/app'],
+    win32: [path.join(process.env.LOCALAPPDATA || '', 'Programs/Microsoft VS Code/resources/app'), path.join(process.env.PROGRAMFILES || '', 'Microsoft VS Code/resources/app')],
+  }[process.platform] || []
+  return candidates.find((p) => fs.existsSync(p)) || ''
+}
+
+const needsEditor = (what) => async () => { throw new Error(`${what} needs VS Code — it is not available in the terminal`) }
+
+const workspace = {
+  fs: fileSystem,
+  get workspaceFolders() { return [{ uri: Uri.file(state.root), name: path.basename(state.root), index: 0 }] },
+  getWorkspaceFolder(uri) {
+    const p = asUri(uri).fsPath
+    return p === state.root || p.startsWith(state.root + path.sep) ? this.workspaceFolders[0] : undefined
+  },
+  asRelativePath(p) { return path.relative(state.root, typeof p === 'string' ? p : p.fsPath) },
+  findFiles,
+  textDocuments: [],
+  async openTextDocument(uri) {
+    const u = asUri(uri)
+    const text = await fs.promises.readFile(u.fsPath, 'utf8')
+    return { uri: u, isDirty: false, isClosed: false, languageId: path.extname(u.fsPath).slice(1), lineCount: text.split('\n').length, getText: () => text, save: async () => true }
+  },
+  getConfiguration,
+  onDidChangeConfiguration: noEvent,
+  onDidChangeTextDocument: noEvent,
+  onDidSaveTextDocument: noEvent,
+  onDidChangeNotebookDocument: noEvent,
+  openNotebookDocument: needsEditor('running a notebook cell'),
+  createFileSystemWatcher: () => ({ onDidChange: noEvent, onDidCreate: noEvent, onDidDelete: noEvent, dispose() {} }),
+}
+
+module.exports = {
+  version: '1.139.0-cli',
+  state,
+  Uri,
+  FileType,
+  RelativePattern,
+  EventEmitter,
+  Disposable: class { constructor(fn) { this.dispose = fn || (() => {}) } },
+  Position: class { constructor(line, character) { this.line = line; this.character = character } },
+  Range: class { constructor(a, b, c, d) { this.start = { line: a, character: b }; this.end = { line: c, character: d } } },
+  DiagnosticSeverity: { Error: 0, Warning: 1, Information: 2, Hint: 3 },
+  ConfigurationTarget: { Global: 1, Workspace: 2, WorkspaceFolder: 3 },
+  NotebookCellKind: { Markup: 1, Code: 2 },
+  SymbolKind: new Proxy({}, { get: (_, k) => k }),
+  workspace,
+  languages: { getDiagnostics: () => [], onDidChangeDiagnostics: noEvent },
+  window: {
+    activeTextEditor: undefined,
+    visibleTextEditors: [],
+    createOutputChannel: outputChannel,
+    showInformationMessage: async () => undefined,
+    showWarningMessage: async () => undefined,
+    showErrorMessage: async () => undefined,
+    showQuickPick: async () => undefined,
+    showInputBox: async () => undefined,
+    showNotebookDocument: needsEditor('showing a notebook'),
+  },
+  commands: { executeCommand: needsEditor('that command'), registerCommand: () => ({ dispose() {} }) },
+  env: { appRoot: appRoot(), uriScheme: 'vscode', clipboard: { writeText: async () => {}, readText: async () => '' }, openExternal: async () => false },
+  extensions: { getExtension: () => undefined },
+}