@davait/aipictury 1.9.2

package/ext/context.js

@@ -0,0 +1,241 @@
+'use strict'
+// What the project tells the agent, in the files other agents already use:
+// - instructions: AIPICTURY.md, AGENTS.md, CLAUDE.md (and CLAUDE.local.md, .claude/CLAUDE.md)
+//   at the workspace root, read into every conversation — so a project set up for Claude
+//   Code or another agent works here unchanged;
+// - skills: <dir>/<name>/SKILL.md under .aipictury/skills or .claude/skills (project or home),
+//   listed to the model by name and description and read in full when it uses one;
+// - commands: .aipictury/commands/*.md or .claude/commands/*.md, run as /name arguments.
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { root } = require('./paths')
+const prefs = require('./prefs')
+
+const INSTRUCTION_FILES = ['AIPICTURY.md', 'AGENTS.md', 'CLAUDE.md', 'CLAUDE.local.md', '.claude/CLAUDE.md']
+const CAP = 20_000
+
+function read(file) { try { return fs.readFileSync(file, 'utf8') } catch { return null } }
+function base() { try { return root().fsPath } catch { return null } }
+
+/** The project's instruction files, for the system prompt. */
+function instructions() {
+  const dir = base()
+  const found = []
+  const home = read(path.join(os.homedir(), '.aipictury', 'AIPICTURY.md'))
+  if (home?.trim()) found.push({ name: '~/.aipictury/AIPICTURY.md', text: home })
+  if (dir) {
+    for (const name of INSTRUCTION_FILES) {
+      const text = read(path.join(dir, name))
+      if (text?.trim()) found.push({ name, text })
+    }
+  }
+  return found
+}
+
+function instructionsBlock() {
+  const found = instructions()
+  if (!found.length) return ''
+  return '\n\nThe project gives these instructions. Follow them; they override your defaults:\n'
+    + found.map((f) => `\n<instructions file="${f.name}">\n${f.text.slice(0, CAP)}${f.text.length > CAP ? '\n…' : ''}\n</instructions>`).join('\n')
+}
+
+/** Frontmatter (--- key: value ---) and the body of a Markdown file. */
+function frontmatter(text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text)
+  if (!m) return { meta: {}, body: text }
+  const meta = {}
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = /^([\w-]+):\s*(.*)$/.exec(line)
+    if (kv) meta[kv[1]] = kv[2].replace(/^["']|["']$/g, '').trim()
+  }
+  return { meta, body: text.slice(m[0].length) }
+}
+
+function dirs(kind) {
+  return sourceDirs(kind).map((d) => d.dir)
+}
+
+/** Where a kind of thing (commands, skills, agents, output-styles) is kept: the project's, yours,
+ *  then the plugins' that are on — each plugin's with its name, for /plugin:command. */
+function sourceDirs(kind) {
+  const dir = base()
+  const list = []
+  if (dir) list.push({ dir: path.join(dir, '.aipictury', kind) }, { dir: path.join(dir, '.claude', kind) })
+  list.push({ dir: path.join(os.homedir(), '.aipictury', kind) }, { dir: path.join(os.homedir(), '.claude', kind) })
+  try { list.push(...require('./plugins').dirs(dir || undefined, kind)) } catch { /* no plugins */ }
+  return list
+}
+
+/** Every skill: { name, description, file, dir }. The first found by a name wins. */
+function skills() {
+  const out = new Map()
+  for (const { dir: d, plugin } of sourceDirs('skills')) {
+    let entries
+    try { entries = fs.readdirSync(d, { withFileTypes: true }) } catch { continue }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue
+      const file = path.join(d, e.name, 'SKILL.md')
+      const text = read(file)
+      if (!text) continue
+      const { meta } = frontmatter(text)
+      const name = plugin ? `${plugin}:${meta.name || e.name}` : meta.name || e.name
+      if (!out.has(name)) out.set(name, { name, description: meta.description || '', file, dir: path.join(d, e.name), plugin })
+    }
+  }
+  return [...out.values()]
+}
+
+/** How each skill is shown to the model: 'on' (name and description), 'name' (name only),
+ *  'off' (hidden, and refused). From the settings files ("skillVisibility"). */
+function skillVisibility() {
+  return prefs.load(base() || undefined).merged.skillVisibility || {}
+}
+
+/** The skills the model may use, each with how it is shown. */
+function visibleSkills() {
+  const seen = skillVisibility()
+  return skills().map((s) => ({ ...s, visibility: ['on', 'name', 'off'].includes(seen[s.name]) ? seen[s.name] : 'on' }))
+    .filter((s) => s.visibility !== 'off')
+}
+
+/** A skill's instructions, for the model. */
+function useSkill(args) {
+  const all = visibleSkills()
+  const skill = all.find((s) => s.name === String(args.name || args.skill || ''))
+  if (!skill) throw new Error(`no skill ${args.name} — available: ${all.map((s) => s.name).join(', ') || 'none'}`)
+  const { body } = frontmatter(read(skill.file) || '')
+  return `Skill "${skill.name}" (files in ${skill.dir}):\n\n${body.trim()}${args.arguments ? `\n\nArguments: ${args.arguments}` : ''}`
+}
+
+/** Custom slash commands: { name, description, hint, file }. */
+function commands() {
+  const out = new Map()
+  for (const { dir: d, plugin } of sourceDirs('commands')) {
+    let files
+    try { files = fs.readdirSync(d).filter((f) => f.endsWith('.md')) } catch { continue }
+    for (const f of files) {
+      const name = plugin ? `${plugin}:${f.replace(/\.md$/, '')}` : f.replace(/\.md$/, '')
+      if (out.has(name)) continue
+      const { meta, body } = frontmatter(read(path.join(d, f)) || '')
+      out.set(name, { name, description: meta.description || body.trim().split('\n')[0].slice(0, 80),
+        hint: meta['argument-hint'] || '', file: path.join(d, f) })
+    }
+  }
+  return [...out.values()]
+}
+
+/** "/name args" → the prompt it stands for, or null when it is not a custom command. */
+function expandCommand(text) {
+  const m = /^\/([\w:.-]+)(?:\s+([\s\S]*))?$/.exec(String(text).trim())
+  if (!m) return null
+  const cmd = commands().find((c) => c.name === m[1])
+  if (!cmd) return null
+  const args = (m[2] || '').trim()
+  const parts = args.split(/\s+/).filter(Boolean)
+  const { body } = frontmatter(read(cmd.file) || '')
+  let prompt = body.replace(/\$ARGUMENTS/g, args).replace(/\$(\d+)/g, (_, n) => parts[Number(n) - 1] ?? '')
+  if (args && !/\$ARGUMENTS|\$\d/.test(body)) prompt += `\n\n${args}`
+  return prompt.trim()
+}
+
+/** What a command's frontmatter grants while it runs: allowed-tools (rules) and a model. */
+function commandMeta(text) {
+  const m = /^\/([\w:.-]+)/.exec(String(text).trim())
+  const cmd = m && commands().find((c) => c.name === m[1])
+  if (!cmd) return { allowedTools: [], model: null }
+  const { meta } = frontmatter(read(cmd.file) || '')
+  const raw = meta['allowed-tools'] || ''
+  // "Bash(git add:*), Bash(git status:*)" — commas between rules, not inside their ( ).
+  const allowedTools = []
+  let depth = 0
+  let cur = ''
+  for (const c of String(raw)) {
+    if (c === '(') depth += 1
+    if (c === ')') depth -= 1
+    if (c === ',' && depth === 0) { if (cur.trim()) allowedTools.push(cur.trim()); cur = '' } else cur += c
+  }
+  if (cur.trim()) allowedTools.push(cur.trim())
+  return { allowedTools, model: meta.model || null }
+}
+
+/** Runs a command's inline shell commands (!`git status`) and puts their output in its place —
+ *  each only when `allowed(command)` says so; otherwise the prompt says it was not run. */
+async function runInline(prompt, { cwd, allowed, timeout = 30_000 } = {}) {
+  const { exec } = require('child_process')
+  const found = [...String(prompt).matchAll(/!`([^`\n]+)`/g)]
+  let out = String(prompt)
+  for (const m of found) {
+    const command = m[1].trim()
+    let text
+    if (!(await allowed(command))) text = `[not run: ${command} — not allowed by the command's allowed-tools or your rules]`
+    else {
+      text = await new Promise((resolve) => exec(command, { cwd, timeout, maxBuffer: 1_000_000, shell: '/bin/bash' },
+        (error, stdout, stderr) => resolve(`${stdout}${stderr}`.trim().slice(0, 8000) || (error ? `(failed: ${error.message.split('\n')[0]})` : '(no output)'))))
+    }
+    out = out.replace(m[0], text)
+  }
+  return out
+}
+
+// ---- agents: helpers with a role (.aipictury/agents, .claude/agents, plugins) ----
+
+function agents() {
+  const out = new Map()
+  for (const { dir: d, plugin } of sourceDirs('agents')) {
+    let files
+    try { files = fs.readdirSync(d).filter((f) => f.endsWith('.md')) } catch { continue }
+    for (const f of files) {
+      const { meta, body } = frontmatter(read(path.join(d, f)) || '')
+      const base = meta.name || f.replace(/\.md$/, '')
+      const name = plugin ? `${plugin}:${base}` : base
+      const tools = Array.isArray(meta.tools) ? meta.tools : String(meta.tools || '').split(',').map((t) => t.trim()).filter(Boolean)
+      if (!out.has(name)) out.set(name, { name, description: meta.description || '', tools, model: meta.model || null, body: body.trim(), file: path.join(d, f) })
+    }
+  }
+  return [...out.values()]
+}
+
+// ---- output styles: how the agent writes its answers ----
+
+const STYLES = [
+  { name: 'Default', description: 'Concise, focused on getting the work done', builtIn: true, body: '' },
+  { name: 'Explanatory', description: 'Does the work, and explains the choices in brief notes', builtIn: true,
+    body: 'Besides doing the task, help the user understand it. Before or after a piece of code, add a short "Insight" '
+      + 'note — two or three lines — on why it is written that way: the patterns of this codebase it follows, the '
+      + 'trade-off taken, an alternative not taken. Keep the notes specific to the code at hand, never generic.' },
+  { name: 'Learning', description: 'Teaches as it goes, and leaves small meaningful parts for you to write', builtIn: true,
+    body: 'Teach as you work. Explain your reasoning as you go. When a small, meaningful piece of logic comes up (a '
+      + 'condition, a loop body, a function of a few lines), do not write it: leave a clearly marked TODO(human) in '
+      + 'the code with a hint, and ask the user to write it. Do the routine parts — wiring, boilerplate — yourself.' },
+]
+
+/** Every output style: the built-in ones and those in .aipictury/output-styles (or .claude/…). */
+function outputStyles() {
+  const out = new Map(STYLES.map((s) => [s.name.toLowerCase(), s]))
+  for (const d of dirs('output-styles')) {
+    let files
+    try { files = fs.readdirSync(d).filter((f) => f.endsWith('.md')) } catch { continue }
+    for (const f of files) {
+      const { meta, body } = frontmatter(read(path.join(d, f)) || '')
+      const name = meta.name || f.replace(/\.md$/, '')
+      if (!out.has(name.toLowerCase())) out.set(name.toLowerCase(), { name, description: meta.description || '', body: body.trim(), file: path.join(d, f) })
+    }
+  }
+  return [...out.values()]
+}
+
+/** The style in force (settings files' "outputStyle"), Default when none or unknown. */
+function outputStyle() {
+  const wanted = String(prefs.load(base() || undefined).merged.outputStyle || 'Default').toLowerCase()
+  return outputStyles().find((s) => s.name.toLowerCase() === wanted) || STYLES[0]
+}
+
+/** What the system prompt gains from the style in force. */
+function styleBlock() {
+  const style = outputStyle()
+  return style.body ? `\n\n## Output style: ${style.name}\n${style.body}` : ''
+}
+
+module.exports = { commandMeta, runInline, agents, sourceDirs, visibleSkills, skillVisibility, outputStyles, outputStyle, styleBlock, STYLES, instructions, instructionsBlock, skills, useSkill, commands, expandCommand, frontmatter, INSTRUCTION_FILES }

package/ext/deps.js

@@ -0,0 +1,142 @@
+'use strict'
+// New dependencies are the user's choice. The prompt says so, but a model sometimes picks a
+// library anyway — writes an Express server, runs `npm install multer` — and the user is left
+// with a stack they did not choose, costly to undo. So the agent itself holds such a call:
+// installing a package, or writing code that imports one, that the user never named and the
+// project does not already use. The model is told to ask first; once the user (or, in Auto
+// mode, the recommended option) has chosen, the name is in the conversation and it goes ahead.
+const { builtinModules } = require('module')
+const vscode = require('vscode')
+
+// Installing: the package names that follow these commands.
+const INSTALL = /^(?:sudo\s+)?(?:npm\s+(?:install|i|add)|pnpm\s+(?:add|install|i)|yarn\s+(?:global\s+)?add|bun\s+(?:add|install|i)|pip3?\s+install|python3?\s+-m\s+pip\s+install|poetry\s+add|uv\s+(?:add|pip\s+install)|pipx\s+install|cargo\s+add|go\s+get|gem\s+install|composer\s+require)\s+(.+)$/i
+// Options whose next word is a value, not a package.
+const VALUED = new Set(['-r', '--requirement', '-c', '--constraint', '-e', '--editable', '-i', '--index-url',
+  '--extra-index-url', '-t', '--target', '--prefix', '--registry', '--save-prefix', '-f', '--find-links'])
+// The user leaving the choice to the agent.
+const DELEGATED = /\b(you (choose|pick|decide)|your (choice|call)|whatever you (want|think|prefer)|any (library|package|framework)|(elegí|elija|elige|decid[ií]) vos|lo que (quieras|prefieras)|a tu criterio|como quieras)\b/i
+const BUILTIN = new Set(builtinModules.map((m) => m.replace(/^node:/, '')))
+
+/** The base name a package is known by: scope kept, version, extras and paths dropped. */
+function baseName(spec) {
+  let s = String(spec).trim().replace(/^['"]|['"]$/g, '')
+  if (!s || /^(\.|\/|~|https?:|git\+|file:)/.test(s) || /\.(txt|toml|cfg|whl|tar\.gz|tgz)$/.test(s)) return ''
+  // A Go module is its whole path: github.com/gin-gonic/gin.
+  if (/^[\w-]+(\.[\w-]+)+\/[^\s]+/.test(s)) return s.replace(/@[^/]*$/, '').toLowerCase()
+  if (s.startsWith('@')) return s.split('/').slice(0, 2).join('/').replace(/@[^/@]*$/, (m) => (m.includes('/') ? m : '')).toLowerCase()
+  return s.split(/[@=<>!~[;\s/]/)[0].toLowerCase()
+}
+
+/** The packages a shell command would install. */
+function installed(command) {
+  const names = []
+  for (const part of String(command || '').split(/\s*(?:&&|\|\||;)\s*/)) {
+    const m = INSTALL.exec(part.trim())
+    if (!m) continue
+    const words = m[1].split(/\s+/)
+    for (let i = 0; i < words.length; i += 1) {
+      if (VALUED.has(words[i])) { i += 1; continue }
+      if (words[i].startsWith('-')) continue
+      const name = baseName(words[i])
+      if (name) names.push(name)
+    }
+  }
+  return names
+}
+
+/** The third-party packages a JavaScript or TypeScript file imports. */
+function imported(path, content) {
+  if (!/\.(m?[jt]sx?|cjs)$/i.test(String(path || ''))) return []
+  const names = new Set()
+  const text = String(content || '')
+  const found = /(?:\bimport\s+(?:[^'"()]*?\s+from\s+)?|\bexport\s+[^'"()]*?\s+from\s+|\brequire\s*\(\s*|\bimport\s*\(\s*)['"]([^'"]+)['"]/g
+  for (const m of text.matchAll(found)) {
+    const spec = m[1]
+    if (/^(\.|\/|node:|#|~\/|@\/)/.test(spec)) continue
+    const name = baseName(spec)
+    if (name && !BUILTIN.has(name)) names.add(name)
+  }
+  return [...names]
+}
+
+/** The packages a tool call brings in: installed by a command, or imported by a file written. */
+function brings(name, args) {
+  if (name === 'run_command') return installed(args?.command)
+  if (name === 'write_file') return imported(args?.path, args?.content)
+  if (name === 'edit_file') {
+    const edits = Array.isArray(args?.edits) ? args.edits : [args || {}]
+    return [...new Set(edits.flatMap((e) => imported(args?.path, e.new_text ?? e.new_string ?? '')))]
+  }
+  return []
+}
+
+/** What the user has said in this conversation, and what they chose when asked. */
+function saidByUser(messages, fromUser) {
+  return messages
+    .filter((m) => fromUser.has(m) || (m.role === 'tool' && m.tool_name === 'ask_user'))
+    .map((m) => (typeof m.content === 'string' ? m.content : (m.content || []).map((p) => p.text || '').join(' ')))
+    .join('\n')
+}
+
+/** Every dependency the workspace already declares, from its manifests — within 10 s: on a
+ *  workspace too big to scan in time, fewer are known, and the agent asks rather than waits. */
+async function declared() {
+  let timer
+  const late = new Promise((resolve) => { timer = setTimeout(() => resolve(new Set()), 10_000) })
+  try { return await Promise.race([scanManifests(), late]) } finally { clearTimeout(timer) }
+}
+
+async function scanManifests() {
+  const names = new Set()
+  const read = async (uri) => new TextDecoder().decode(await vscode.workspace.fs.readFile(uri))
+  try {
+    for (const uri of await vscode.workspace.findFiles('**/package.json', '**/node_modules/**', 30)) {
+      try {
+        const pkg = JSON.parse(await read(uri))
+        for (const key of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+          for (const dep of Object.keys(pkg[key] || {})) names.add(dep.toLowerCase())
+        }
+      } catch { /* not JSON */ }
+    }
+    for (const uri of await vscode.workspace.findFiles('**/{requirements*.txt,pyproject.toml,Pipfile,Cargo.toml,go.mod,Gemfile,composer.json}', '**/{node_modules,.venv,venv}/**', 30)) {
+      try {
+        for (const word of (await read(uri)).toLowerCase().match(/[a-z0-9@][a-z0-9._/@-]*/g) || []) names.add(word.replace(/^["']|["',]$/g, ''))
+      } catch { /* unreadable */ }
+    }
+  } catch { /* no workspace */ }
+  return names
+}
+
+/**
+ * The packages in this call the user has not chosen, or none. A name counts as chosen when
+ * the project already declares it (or its @types), the user wrote it, or picked it when asked.
+ * `attempts` counts holds per package: after two, the call goes through — the model has been
+ * told twice, and a hold must never become a dead end.
+ */
+function unchosen(names, said, known, attempts) {
+  if (!names.length || DELEGATED.test(said)) return []
+  const text = said.toLowerCase()
+  const words = new Set(text.match(/[a-z0-9@][a-z0-9._/@+-]*/g) || [])
+  const chosen = (n) => known.has(n) || known.has(n.replace(/^@types\//, '')) || words.has(n)
+    || text.includes(n)
+    // @sentry/node is named by "sentry"; github.com/gin-gonic/gin by "gin".
+    || (n.startsWith('@') ? words.has(n.slice(1).split('/')[0]) : n.includes('/') && words.has(n.split('/').pop()))
+  const open = names.filter((n) => !chosen(n) && (attempts.get(n) || 0) < 2)
+  for (const n of open) attempts.set(n, (attempts.get(n) || 0) + 1)
+  return open
+}
+
+/** What the model is told instead of the call running. */
+function holdNote(names, { helper = false } = {}) {
+  const list = names.map((n) => `\`${n}\``).join(', ')
+  const head = `Not run: this brings in ${list}, which the user has not chosen and the project does not `
+    + 'use yet. Which library, framework, database or service to depend on is the user\'s decision. '
+  if (helper) {
+    return head + 'You cannot ask them from here: end with your report, saying which choice is needed, '
+      + 'the real options and the one you recommend, so the main agent asks.'
+  }
+  return head + 'Ask with ask_user first — 2 to 4 real options, your recommended one first with "(Recommended)", '
+    + 'shaped by what you found in the project — then go ahead with what they choose.'
+}
+
+module.exports = { installed, imported, brings, saidByUser, declared, unchosen, holdNote, baseName }