pi-obsidian-memory 0.0.1 → 0.1.1

package/src/domain/shell-edit/constants.ts

@@ -0,0 +1,125 @@
+import { NPM_VALUE_FLAGS } from "#src/domain/tool-flags"
+import type { ShellEditQuestionName, ShellEditQuestions, ShellEditScores } from "./types.ts"
+
+export const SCRIPT_EXTENSION = /\.(?:sh|ps1)$/i
+
+export const LEADING_ENV_ASSIGNMENTS = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s"'])*\s+)+/
+
+export const EXECUTABLE_SUFFIX = /\.exe$/
+
+export const LAST_SEGMENT_START = /[^\\/]*$/
+
+const EVAL_AND_PRINT_FLAGS = ["-e", "--eval", "-p", "--print"]
+
+const PYTHON_INLINE_CODE_FLAGS = ["-c", "-m"]
+
+const SHELL_INLINE_CODE_FLAGS = ["-c"]
+
+export const INLINE_CODE_FLAGS = new Map([
+  ["node", [...EVAL_AND_PRINT_FLAGS, "-c", "--check"]],
+  ["tsx", EVAL_AND_PRINT_FLAGS],
+  ["ts-node", EVAL_AND_PRINT_FLAGS],
+  ["python", PYTHON_INLINE_CODE_FLAGS],
+  ["python3", PYTHON_INLINE_CODE_FLAGS],
+  ["py", PYTHON_INLINE_CODE_FLAGS],
+  ["bash", SHELL_INLINE_CODE_FLAGS],
+  ["sh", SHELL_INLINE_CODE_FLAGS],
+])
+
+export const BUN_INLINE_CODE_FLAGS = EVAL_AND_PRINT_FLAGS
+
+export const CONFIG_FILE_FLAGS = ["-c", "--config"]
+
+export const RUN_SUBCOMMAND = "run"
+
+export const NO_FLAGS: string[] = []
+
+export const PACKAGE_MANAGERS = new Map([
+  ["npm", NPM_VALUE_FLAGS],
+  ["pnpm", NO_FLAGS],
+  ["yarn", NO_FLAGS],
+])
+
+export const BUN_SOURCE_FILE = /[\\/]|\.(?:[cm]?[jt]sx?|sh|ps1)$/i
+
+export const PRELOAD_FLAGS = ["-r", "--require", "--import", "--preload", "--loader", "--experimental-loader"]
+
+export const PACKAGE_RUN_COMMANDS = ["run", "run-script"]
+
+export const PACKAGE_DIRECT_SCRIPTS = ["test", "start"]
+
+export const SHELL_EDIT_QUESTION_NAMES: readonly ShellEditQuestionName[] = [
+  "redirection",
+  "in_place",
+  "inline_code",
+  "script_writes",
+  "copy_download",
+  "hardlink",
+]
+
+export const SHELL_EDIT_QUESTIONS: ShellEditQuestions = {
+  redirection: {
+    type: "bool",
+    instructions:
+      "Does `command` write output into a file through a redirection (`>` or `>>`) or a file-writing cmdlet (`tee`, `Out-File`, `Set-Content`, `Add-Content`)?",
+    criteria: { true: "`command` sends output into a file", false: "`command` writes no output into any file" },
+  },
+  in_place: {
+    type: "bool",
+    instructions:
+      "Does `command` change an existing file in place, for example with `sed -i`, `perl -pi`, or text read from a file, changed with `-replace` and written back to it, rather than through a linter, formatter, test runner, build, git or a package manager?",
+    criteria: {
+      true: "`command` rewrites an existing file in place",
+      false: "`command` leaves existing files' contents as they are",
+    },
+  },
+  inline_code: {
+    type: "bool",
+    instructions:
+      "Does `command` carry inline code (`node -e`, `python -c`, a PowerShell `-Command` block or similar) whose code creates or writes a file?",
+    criteria: {
+      true: "the inline code in `command` creates or writes a file",
+      false: "`command` has no inline code, or its inline code writes no file",
+    },
+  },
+  script_writes: {
+    type: "bool",
+    instructions:
+      "Does the code in any `scripts[*].text` create or write a file with its own code, rather than only launching a linter, formatter, test runner, build, git or a package manager?",
+    criteria: {
+      true: "a script's own code creates or writes a file",
+      false: "no script's own code creates or writes a file",
+    },
+  },
+  copy_download: {
+    type: "bool",
+    instructions:
+      "Does `command` create a file by copying or downloading content (`cp`, `Copy-Item`, `curl -o`, `Invoke-WebRequest -OutFile`), other than through git or a package manager?",
+    criteria: {
+      true: "`command` creates a file by copying or downloading",
+      false: "`command` copies and downloads no file",
+    },
+  },
+  hardlink: {
+    type: "bool",
+    instructions:
+      "Does `command` create a hardlink (`ln` without `-s`, `New-Item -ItemType HardLink`, `mklink /H`, `fsutil hardlink create`)?",
+    criteria: { true: "`command` creates a hardlink", false: "`command` creates no hardlink" },
+  },
+}
+
+export const SHELL_EDIT_CUTOFFS: ShellEditScores = {
+  redirection: 0.5,
+  in_place: 0.5,
+  inline_code: 0.5,
+  script_writes: 0.5,
+  copy_download: 0.5,
+  hardlink: 0.5,
+}
+
+export const SHELL_EDIT_REFUSED = "Refused by the shell-edit guard"
+
+export const SHELL_EDIT_UNCHECKED = "Refused: the shell-edit guard could not check this command"
+
+export const SHELL_EDIT_GUIDANCE =
+  "The shell never creates or changes files: use the edit or write tool. Deleting, moving and renaming files, linters, formatters, git, npm and test runners stay allowed."

package/src/domain/shell-edit/executed-files.ts

@@ -0,0 +1,154 @@
+import { BUN_FOLDER_FLAGS, BUN_VALUE_FLAGS, INTERPRETER_VALUE_FLAGS } from "#src/domain/command-flags"
+import { NPM_PREFIX_FLAGS, NPM_WORKSPACE_FLAGS, POWERSHELL_PARAMETERS } from "#src/domain/tool-flags"
+import { commandSegments } from "./command-segments.ts"
+import { commandWords } from "./command-words.ts"
+import {
+  BUN_INLINE_CODE_FLAGS,
+  BUN_SOURCE_FILE,
+  CONFIG_FILE_FLAGS,
+  EXECUTABLE_SUFFIX,
+  INLINE_CODE_FLAGS,
+  LAST_SEGMENT_START,
+  LEADING_ENV_ASSIGNMENTS,
+  NO_FLAGS,
+  PACKAGE_DIRECT_SCRIPTS,
+  PACKAGE_MANAGERS,
+  PACKAGE_RUN_COMMANDS,
+  PRELOAD_FLAGS,
+  RUN_SUBCOMMAND,
+  SCRIPT_EXTENSION,
+} from "./constants.ts"
+import { powershellFiles, scriptFile } from "./powershell-files.ts"
+import type { ExecutedFile, FolderRead, InterpreterRules } from "./types.ts"
+
+export function executedFiles(command: string): ExecutedFile[] {
+  const found = new Map<string, ExecutedFile>()
+  for (const segment of commandSegments(command)) {
+    for (const file of segmentFiles(segment)) found.set(JSON.stringify(file), file)
+  }
+  return [...found.values()]
+}
+
+function segmentFiles(segment: string): ExecutedFile[] {
+  const [first, ...args] = commandWords(segment.replace(LEADING_ENV_ASSIGNMENTS, ""))
+  if (typeof first !== "string") return []
+  const program = programName(first)
+  const inlineCode = INLINE_CODE_FLAGS.get(program)
+  const withValue = INTERPRETER_VALUE_FLAGS.get(program)
+  if (inlineCode && withValue) {
+    return interpreterFiles(args, { inlineCode, withValue, folderFlags: NO_FLAGS, mainFile: scriptFile })
+  }
+  if (program === "bun") return bunFiles(args)
+  if (program === "deno") return denoFiles(args)
+  const powershellParameters = POWERSHELL_PARAMETERS.get(program)
+  if (powershellParameters) return powershellFiles(args, powershellParameters)
+  const packageFlags = PACKAGE_MANAGERS.get(program)
+  if (packageFlags) return packageScripts(args, packageFlags)
+  if (SCRIPT_EXTENSION.test(first)) return [scriptFile(first)]
+  return []
+}
+
+function programName(token: string): string {
+  const name = token.slice(token.search(LAST_SEGMENT_START))
+  return name.toLowerCase().replace(EXECUTABLE_SUFFIX, "")
+}
+
+function packageScript(name: string, prefix: string): ExecutedFile {
+  return { kind: "package-script", name, prefix }
+}
+
+function bunRunTarget(name: string, folder: string): ExecutedFile {
+  if (BUN_SOURCE_FILE.test(name)) return scriptFile(name)
+  return packageScript(name, folder)
+}
+
+function bunFiles(args: string[]): ExecutedFile[] {
+  const rules = {
+    inlineCode: BUN_INLINE_CODE_FLAGS,
+    withValue: BUN_VALUE_FLAGS,
+    folderFlags: BUN_FOLDER_FLAGS,
+    mainFile: scriptFile,
+  }
+  if (args[0] === RUN_SUBCOMMAND) return interpreterFiles(args.slice(1), { ...rules, mainFile: bunRunTarget })
+  return interpreterFiles(args, rules)
+}
+
+function denoFiles(args: string[]): ExecutedFile[] {
+  if (args[0] !== RUN_SUBCOMMAND) return []
+  const rules = { inlineCode: NO_FLAGS, withValue: CONFIG_FILE_FLAGS, folderFlags: NO_FLAGS, mainFile: scriptFile }
+  return interpreterFiles(args.slice(1), rules)
+}
+
+function assignedValue(arg: string, flags: string[]): string {
+  const equals = arg.indexOf("=")
+  if (equals < 0 || !flags.includes(arg.slice(0, equals))) return ""
+  return arg.slice(equals + 1)
+}
+
+function isAssignment(arg: string, flags: string[]): boolean {
+  return assignedValue(arg, flags) !== ""
+}
+
+function folderRead(args: string[], index: number, flags: string[]): FolderRead {
+  const arg = args[index]
+  const next = args[index + 1]
+  if (typeof arg !== "string") return { folder: "", width: 0 }
+  if (flags.includes(arg) && typeof next === "string") return { folder: next, width: 2 }
+  if (isAssignment(arg, flags)) return { folder: assignedValue(arg, flags), width: 1 }
+  return { folder: "", width: 0 }
+}
+
+function interpreterFiles(args: string[], rules: InterpreterRules): ExecutedFile[] {
+  const files: ExecutedFile[] = []
+  let folder = ""
+  let index = 0
+  for (let arg = args[index]; typeof arg === "string"; arg = args[index]) {
+    const next = args[index + 1]
+    const read = folderRead(args, index, rules.folderFlags)
+    if (rules.inlineCode.includes(arg)) return files
+    if (read.width > 0) {
+      folder = read.folder
+      index += read.width
+    } else if (rules.withValue.includes(arg)) {
+      index += 2
+    } else if (PRELOAD_FLAGS.includes(arg)) {
+      if (typeof next === "string") files.push(scriptFile(next))
+      index += 2
+    } else if (arg.startsWith("-")) {
+      index += 1
+    } else {
+      return [...files, rules.mainFile(arg, folder)]
+    }
+  }
+  return files
+}
+
+function packageScriptOf(words: string[], prefix: string): ExecutedFile[] {
+  const [first, second] = words
+  if (typeof first !== "string") return []
+  if (PACKAGE_DIRECT_SCRIPTS.includes(first)) return [packageScript(first, prefix)]
+  if (PACKAGE_RUN_COMMANDS.includes(first) && typeof second === "string") return [packageScript(second, prefix)]
+  return []
+}
+
+function packageScripts(args: string[], valueFlags: string[]): ExecutedFile[] {
+  const prefixFlags = NPM_PREFIX_FLAGS.filter((flag) => valueFlags.includes(flag))
+  const workspaceFlags = NPM_WORKSPACE_FLAGS.filter((flag) => valueFlags.includes(flag))
+  const words: string[] = []
+  let prefix = ""
+  let index = 0
+  for (let arg = args[index]; typeof arg === "string" && arg !== "--"; arg = args[index]) {
+    const read = folderRead(args, index, prefixFlags)
+    if (workspaceFlags.includes(arg) || isAssignment(arg, workspaceFlags)) return []
+    if (read.width > 0) {
+      prefix = read.folder
+      index += read.width
+    } else if (valueFlags.includes(arg)) {
+      index += 2
+    } else {
+      if (!arg.startsWith("-")) words.push(arg)
+      index += 1
+    }
+  }
+  return packageScriptOf(words, prefix)
+}

package/src/domain/shell-edit/index.ts

@@ -0,0 +1,6 @@
+export * from "./command-segments.ts"
+export * from "./command-words.ts"
+export * from "./constants.ts"
+export * from "./executed-files.ts"
+export * from "./rules.ts"
+export * from "./types.ts"

package/src/domain/shell-edit/powershell-files.ts

@@ -0,0 +1,38 @@
+import type { PowerShellParameters } from "#src/domain/tool-flags"
+import type { ExecutedFile } from "./types.ts"
+
+export function scriptFile(path: string): ExecutedFile {
+  return { kind: "script", path }
+}
+
+function parameterName(token: string, parameters: PowerShellParameters): string {
+  if (!token.startsWith("-")) return ""
+  const typed = token.slice(1).toLowerCase()
+  const alias = parameters.aliases.get(typed)
+  if (alias) return alias
+  const names = [...parameters.file, ...parameters.inline, ...parameters.value, ...parameters.switches]
+  if (names.includes(typed)) return typed
+  const matches = names.filter((name) => name.startsWith(typed))
+  const [only] = matches
+  if (matches.length === 1 && typeof only === "string") return only
+  return ""
+}
+
+function fileAfter(args: string[], index: number): ExecutedFile[] {
+  const path = args[index + 1]
+  if (typeof path !== "string") return []
+  return [scriptFile(path)]
+}
+
+export function powershellFiles(args: string[], parameters: PowerShellParameters): ExecutedFile[] {
+  let index = 0
+  for (let arg = args[index]; typeof arg === "string"; arg = args[index]) {
+    if (!arg.startsWith("-")) return [scriptFile(arg)]
+    const name = parameterName(arg, parameters)
+    if (parameters.inline.includes(name)) return []
+    if (parameters.file.includes(name)) return fileAfter(args, index)
+    index += 1
+    if (parameters.value.includes(name)) index += 1
+  }
+  return []
+}

package/src/domain/shell-edit/rules.ts

@@ -0,0 +1,19 @@
+import {
+  SHELL_EDIT_GUIDANCE,
+  SHELL_EDIT_QUESTION_NAMES,
+  SHELL_EDIT_REFUSED,
+  SHELL_EDIT_UNCHECKED,
+} from "./constants.ts"
+import type { ShellEditQuestionName, ShellEditScores } from "./types.ts"
+
+export function firedQuestions(scores: ShellEditScores, cutoffs: ShellEditScores): ShellEditQuestionName[] {
+  return SHELL_EDIT_QUESTION_NAMES.filter((name) => scores[name] >= cutoffs[name])
+}
+
+export function shellEditRefusal(fired: [ShellEditQuestionName, ...ShellEditQuestionName[]]): string {
+  return `${SHELL_EDIT_REFUSED} (${fired.join(", ")}). ${SHELL_EDIT_GUIDANCE}`
+}
+
+export function shellEditUncheckable(cause: string): string {
+  return `${SHELL_EDIT_UNCHECKED}: ${cause.replace(/\.$/, "")}. ${SHELL_EDIT_GUIDANCE}`
+}

package/src/domain/shell-edit/types.ts

@@ -0,0 +1,75 @@
+export interface ScriptFile {
+  kind: "script"
+  path: string
+}
+
+export interface PackageScript {
+  kind: "package-script"
+  name: string
+  prefix: string
+}
+
+export type ExecutedFile = ScriptFile | PackageScript
+
+export type MainFile = (path: string, folder: string) => ExecutedFile
+
+export interface FolderRead {
+  folder: string
+  width: number
+}
+
+export interface InterpreterRules {
+  inlineCode: string[]
+  withValue: string[]
+  folderFlags: string[]
+  mainFile: MainFile
+}
+
+export type ShellEditQuestionName =
+  | "redirection"
+  | "in_place"
+  | "inline_code"
+  | "script_writes"
+  | "copy_download"
+  | "hardlink"
+
+export interface ShellEditCriteria {
+  true: string
+  false: string
+}
+
+export interface ShellEditQuestion {
+  type: "bool"
+  instructions: string
+  criteria: ShellEditCriteria
+}
+
+export interface ShellEditQuestions {
+  redirection: ShellEditQuestion
+  in_place: ShellEditQuestion
+  inline_code: ShellEditQuestion
+  script_writes: ShellEditQuestion
+  copy_download: ShellEditQuestion
+  hardlink: ShellEditQuestion
+}
+
+export interface ShellEditScores {
+  redirection: number
+  in_place: number
+  inline_code: number
+  script_writes: number
+  copy_download: number
+  hardlink: number
+}
+
+export interface ShellEditScript {
+  path: string
+  text: string
+}
+
+export interface ShellEditState {
+  command: string
+  cwd: string
+  scripts: ShellEditScript[]
+  missing: string[]
+}

package/src/domain/tool-flags/constants.ts

@@ -0,0 +1,178 @@
+import type { PowerShellParameters } from "./types.ts"
+
+export const PWSH_PARAMETERS: PowerShellParameters = {
+  file: ["file"],
+  inline: ["command", "commandwithargs", "encodedcommand"],
+  value: [
+    "configurationname",
+    "configurationfile",
+    "custompipename",
+    "executionpolicy",
+    "inputformat",
+    "outputformat",
+    "settingsfile",
+    "windowstyle",
+    "workingdirectory",
+  ],
+  switches: [
+    "login",
+    "interactive",
+    "mta",
+    "noexit",
+    "nologo",
+    "noninteractive",
+    "noprofile",
+    "noprofileloadtime",
+    "sshservermode",
+    "sta",
+    "version",
+    "help",
+  ],
+  aliases: new Map([
+    ["f", "file"],
+    ["c", "command"],
+    ["cwa", "commandwithargs"],
+    ["config", "configurationname"],
+    ["e", "encodedcommand"],
+    ["ec", "encodedcommand"],
+    ["ex", "executionpolicy"],
+    ["ep", "executionpolicy"],
+    ["inp", "inputformat"],
+    ["if", "inputformat"],
+    ["i", "interactive"],
+    ["l", "login"],
+    ["noe", "noexit"],
+    ["nol", "nologo"],
+    ["noni", "noninteractive"],
+    ["nop", "noprofile"],
+    ["o", "outputformat"],
+    ["of", "outputformat"],
+    ["settings", "settingsfile"],
+    ["sshs", "sshservermode"],
+    ["v", "version"],
+    ["w", "windowstyle"],
+    ["wd", "workingdirectory"],
+  ]),
+}
+
+export const WINDOWS_POWERSHELL_PARAMETERS: PowerShellParameters = {
+  file: ["file"],
+  inline: ["command", "encodedcommand"],
+  value: [
+    "psconsolefile",
+    "version",
+    "configurationname",
+    "inputformat",
+    "outputformat",
+    "windowstyle",
+    "executionpolicy",
+    "workingdirectory",
+  ],
+  switches: ["nologo", "noexit", "sta", "mta", "noprofile", "noninteractive", "help"],
+  aliases: new Map([
+    ["c", "command"],
+    ["e", "encodedcommand"],
+    ["ec", "encodedcommand"],
+    ["ep", "executionpolicy"],
+    ["w", "windowstyle"],
+    ["wd", "workingdirectory"],
+  ]),
+}
+
+export const POWERSHELL_PARAMETERS = new Map([
+  ["pwsh", PWSH_PARAMETERS],
+  ["powershell", WINDOWS_POWERSHELL_PARAMETERS],
+])
+
+export const NPM_WORKSPACE_FLAGS = ["--workspace", "-w"]
+
+export const NPM_VALUE_FLAGS = [
+  "--_auth",
+  "--access",
+  "--also",
+  "--audit-level",
+  "--auth-type",
+  "--before",
+  "--ca",
+  "--cache",
+  "--cache-max",
+  "--cache-min",
+  "--cafile",
+  "--call",
+  "-c",
+  "--cert",
+  "--cidr",
+  "--cpu",
+  "--depth",
+  "--diff",
+  "--diff-dst-prefix",
+  "--diff-src-prefix",
+  "--diff-unified",
+  "--editor",
+  "--expect-result-count",
+  "--fetch-retries",
+  "--fetch-retry-factor",
+  "--fetch-retry-maxtimeout",
+  "--fetch-retry-mintimeout",
+  "--fetch-timeout",
+  "--git",
+  "--globalconfig",
+  "--heading",
+  "--https-proxy",
+  "--include",
+  "--init-author-email",
+  "--init-author-name",
+  "--init-author-url",
+  "--init-license",
+  "--init-module",
+  "--init-version",
+  "--install-strategy",
+  "--key",
+  "--libc",
+  "--local-address",
+  "--location",
+  "-L",
+  "--lockfile-version",
+  "--loglevel",
+  "--logs-dir",
+  "--logs-max",
+  "--maxsockets",
+  "--message",
+  "-m",
+  "--node-options",
+  "--noproxy",
+  "--omit",
+  "--only",
+  "--os",
+  "--otp",
+  "--package",
+  "--pack-destination",
+  "--prefix",
+  "-C",
+  "--preid",
+  "--provenance-file",
+  "--proxy",
+  "--registry",
+  "--replace-registry-host",
+  "--save-prefix",
+  "--sbom-format",
+  "--sbom-type",
+  "--scope",
+  "--script-shell",
+  "--searchexclude",
+  "--searchlimit",
+  "--searchopts",
+  "--searchstaleness",
+  "--shell",
+  "--tag",
+  "--tag-version-prefix",
+  "--umask",
+  "--user-agent",
+  "--userconfig",
+  "--viewer",
+  "--which",
+  "--workspace",
+  "-w",
+]
+
+export const NPM_PREFIX_FLAGS = ["--prefix", "-C"]

package/src/domain/tool-flags/index.ts

@@ -0,0 +1,2 @@
+export * from "./constants.ts"
+export * from "./types.ts"

package/src/domain/tool-flags/types.ts

@@ -0,0 +1,7 @@
+export interface PowerShellParameters {
+  file: string[]
+  inline: string[]
+  value: string[]
+  switches: string[]
+  aliases: Map<string, string>
+}

package/src/domain/validation/constants.ts

@@ -0,0 +1 @@
+export const ESCAPED_POINTER = /~[01]/