pi-obsidian-memory 0.0.0 → 0.1.0

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]/

package/src/domain/validation/describe.ts

@@ -0,0 +1,137 @@
+import type { TValidationError } from "typebox/error"
+
+import { ESCAPED_POINTER } from "./constants.ts"
+import type { ErrorMessageOverride } from "./types.ts"
+
+export function describeSchemaErrors(errors: readonly TValidationError[], label: string): string[] {
+  return describeSchemaErrorsWith(errors, label, noOverride)
+}
+
+export function describeSchemaErrorsWith(
+  errors: readonly TValidationError[],
+  label: string,
+  override: ErrorMessageOverride,
+): string[] {
+  return errors
+    .filter((error) => !isReportedUnknownProperty(error, errors))
+    .flatMap((error) => describeError(error, label, override))
+}
+
+function noOverride(): null {
+  return null
+}
+
+function isReportedUnknownProperty(error: TValidationError, errors: readonly TValidationError[]): boolean {
+  if (error.keyword !== "boolean") {
+    return false
+  }
+
+  return errors.some(
+    (other) =>
+      other.keyword === "additionalProperties" &&
+      error.schemaPath === `${other.schemaPath}/additionalProperties` &&
+      other.params.additionalProperties.some((field) =>
+        [field, escapePointer(field)].some((name) => error.instancePath === `${other.instancePath}/${name}`),
+      ),
+  )
+}
+
+function describeError(error: TValidationError, label: string, override: ErrorMessageOverride): string[] {
+  const path = readablePath(error.instancePath)
+
+  if (error.keyword === "additionalProperties") {
+    return error.params.additionalProperties.map((field) => `${joinField(path, field)}: not a known field`)
+  }
+
+  let message = keywordMessage(error)
+  const custom = override(error)
+  if (custom) {
+    message = custom
+  }
+
+  if (path.length === 0) {
+    return [`${label}: ${message}`]
+  }
+
+  return [`${path}: ${message}`]
+}
+
+function keywordMessage(error: TValidationError): string {
+  switch (error.keyword) {
+    case "type":
+      return typeMessage(error.params.type)
+    case "required":
+      return `must have required properties ${error.params.requiredProperties.join(", ")}`
+    case "enum":
+      return "must be equal to one of the allowed values"
+    case "const":
+      return "must be equal to constant"
+    case "pattern":
+      return `must match pattern "${String(error.params.pattern)}"`
+    case "format":
+      return `must match format "${error.params.format}"`
+    case "not":
+      return "must not be valid"
+    case "boolean":
+      return "is not allowed"
+    case "anyOf":
+      return "must match a schema in anyOf"
+    case "oneOf":
+      return "must match exactly one schema in oneOf"
+    default:
+      return limitMessage(error)
+  }
+}
+
+function limitMessage(error: TValidationError): string {
+  switch (error.keyword) {
+    case "minLength":
+      return `must not have fewer than ${error.params.limit} characters`
+    case "maxLength":
+      return `must not have more than ${error.params.limit} characters`
+    case "minItems":
+      return `must not have fewer than ${error.params.limit} items`
+    case "maxItems":
+      return `must not have more than ${error.params.limit} items`
+    case "minimum":
+    case "maximum":
+    case "exclusiveMinimum":
+    case "exclusiveMaximum":
+      return `must be ${error.params.comparison} ${error.params.limit}`
+    default:
+      return `is invalid (${error.keyword})`
+  }
+}
+
+function typeMessage(type: string | string[]): string {
+  if (typeof type === "string") {
+    return `must be ${type}`
+  }
+
+  return `must be either ${type.join(" or ")}`
+}
+
+function readablePath(instancePath: string): string {
+  const segments = instancePath.slice(1).split("/")
+  if (!ESCAPED_POINTER.test(instancePath)) {
+    return segments.join(".")
+  }
+
+  return segments.map(unescapePointer).join(".")
+}
+
+function unescapePointer(field: string): string {
+  return field.replaceAll("~1", "/").replaceAll("~0", "~")
+}
+
+function escapePointer(field: string): string {
+  return field.replaceAll("~", "~0").replaceAll("/", "~1")
+}
+
+function joinField(path: string, field: string): string {
+  if (path.length === 0) {
+    return field
+  }
+
+  return `${path}.${field}`
+}

package/src/domain/validation/index.ts

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

package/src/domain/validation/types.ts

@@ -0,0 +1,3 @@
+import type { TValidationError } from "typebox/error"
+
+export type ErrorMessageOverride = (error: TValidationError) => string | null

package/src/domain/vault-access/absolute-candidate.ts

@@ -0,0 +1,81 @@
+import { posix, win32 } from "node:path"
+import { fileURLToPath } from "node:url"
+
+import type { PathPlatform } from "#src/domain/path-platform"
+import {
+  DRIVE_OR_UNC_START,
+  LOCAL_ADMIN_SHARE,
+  NAMESPACE_PREFIX,
+  NAMESPACE_UNC_PREFIX,
+  TRAILING_NAMESPACE_SEPARATOR,
+  UNICODE_SPACES,
+  WINDOWS_SHELL_DRIVE_PREFIX,
+} from "./constants.ts"
+
+export function absoluteCandidate(raw: string, cwd: string, home: string, platform: PathPlatform): string {
+  if (platform === "win32") {
+    return windowsCandidate(raw, cwd, home)
+  }
+
+  return posix.resolve(cwd, posixExpandedPath(raw, home))
+}
+
+function windowsCandidate(raw: string, cwd: string, home: string): string {
+  const expanded = expandedPath(raw, home)
+  const resolved = win32.resolve(cwd, expanded)
+  const stripped = resolved.replace(NAMESPACE_UNC_PREFIX, "\\\\").replace(NAMESPACE_PREFIX, "")
+  if (!DRIVE_OR_UNC_START.test(stripped)) {
+    return resolved.replace(TRAILING_NAMESPACE_SEPARATOR, "$1")
+  }
+
+  return stripped.replace(LOCAL_ADMIN_SHARE, (_share: string, drive: string) => `${drive.toUpperCase()}:\\`)
+}
+
+function posixExpandedPath(raw: string, home: string): string {
+  const native = withoutAtPrefix(raw.replace(UNICODE_SPACES, " "))
+
+  if (native === "~") {
+    return home
+  }
+  if (native.startsWith("~/")) {
+    return posix.join(home, native.slice(2))
+  }
+  if (native.startsWith("file://")) {
+    return fileURLToPath(native, { windows: false })
+  }
+
+  return native
+}
+
+function expandedPath(raw: string, home: string): string {
+  const spaced = raw.replace(UNICODE_SPACES, " ")
+  const native = windowsShellPath(withoutAtPrefix(spaced))
+
+  if (native === "~") {
+    return home
+  }
+  if (native.startsWith("~/") || native.startsWith("~\\")) {
+    return win32.join(home, native.slice(2))
+  }
+  if (native.startsWith("file://")) {
+    return fileURLToPath(native, { windows: true })
+  }
+
+  return native
+}
+
+function withoutAtPrefix(path: string): string {
+  if (path.startsWith("@")) {
+    return path.slice(1)
+  }
+
+  return path
+}
+
+function windowsShellPath(path: string): string {
+  if (path.startsWith("//") || path.includes("\\")) {
+    return path
+  }
+
+  return path.replace(WINDOWS_SHELL_DRIVE_PREFIX, (_prefix: string, drive: string) => `${drive.toUpperCase()}:/`)
+}

package/src/domain/vault-access/argument-tokens.ts

@@ -0,0 +1,22 @@
+import { QUOTE_CHARACTERS, TOKEN_SEPARATOR } from "./constants.ts"
+
+export function argumentTokens(command: string): string[] {
+  const tokens: string[] = []
+  let current = ""
+  let quote = ""
+  for (const character of command) {
+    if (quote) {
+      if (character === quote) quote = ""
+      else current += character
+    } else if (QUOTE_CHARACTERS.includes(character)) {
+      quote = character
+    } else if (TOKEN_SEPARATOR.test(character)) {
+      if (current) tokens.push(current)
+      current = ""
+    } else {
+      current += character
+    }
+  }
+  if (current) tokens.push(current)
+  return tokens
+}

package/src/domain/vault-access/command-mentions-vault.ts

@@ -0,0 +1,115 @@
+import { isInside } from "#src/domain/config"
+import { type PathPlatform, pathModule } from "#src/domain/path-platform"
+import { argumentTokens } from "./argument-tokens.ts"
+import {
+  COMPARABLE_ADMIN_SHARE,
+  COMPARABLE_NAMESPACE,
+  COMPARABLE_NAMESPACE_UNC,
+  DRIVE_PATH_PREFIXES,
+  FILE_URL_PREFIX,
+  HOME_PREFIXES,
+  PARENT_FOLDER_START,
+  PATH_FOLLOWS,
+  PATH_TOKEN_END,
+  PATH_TOKEN_START,
+  VARIABLE_REFERENCE,
+  WINDOWS_DRIVE_START,
+  WINDOWS_FILE_URL_PREFIX,
+} from "./constants.ts"
+import type { VaultForms } from "./types.ts"
+
+export function commandMentionsVault(
+  command: string,
+  cwd: string,
+  home: string,
+  vaults: string[],
+  platform: PathPlatform,
+): string | null {
+  const text = comparableText(command, platform)
+  const tokens = argumentTokens(command).map((token) => comparableText(token, platform).replace(/(?<=.)\.+$/, ""))
+  for (const vault of vaults) {
+    if (isInside(cwd, vault, platform) || mentionsForms(text, tokens, vaultForms(vault, cwd, home, platform))) {
+      return vault
+    }
+  }
+
+  return null
+}
+
+function mentionsForms(text: string, tokens: string[], forms: VaultForms): boolean {
+  return (
+    forms.anywhere.some((form) => appearsIn(text, form, PATH_TOKEN_END)) ||
+    forms.relative.some((form) => tokens.includes(form) || appearsIn(text, form, PATH_FOLLOWS))
+  )
+}
+
+function vaultForms(vault: string, cwd: string, home: string, platform: PathPlatform): VaultForms {
+  const absolute = comparableText(vault, platform)
+  const shellDriveForms = DRIVE_PATH_PREFIXES.flatMap((prefix) => shellDriveForm(absolute, prefix))
+  const downFromHome = relativeTo(home, vault, platform).filter((path) => !PARENT_FOLDER_START.test(path))
+  const homeForms = downFromHome.flatMap((path) => HOME_PREFIXES.map((prefix) => `${prefix}${path}`))
+  const fromCwd = relativeTo(cwd, vault, platform)
+  const dotSlashForms = fromCwd.filter((path) => !PARENT_FOLDER_START.test(path)).map((path) => `./${path}`)
+
+  return { anywhere: [absolute, ...shellDriveForms, ...homeForms], relative: [...fromCwd, ...dotSlashForms] }
+}
+
+function shellDriveForm(absolute: string, prefix: string): string[] {
+  if (!WINDOWS_DRIVE_START.test(absolute)) {
+    return []
+  }
+
+  return [`${prefix}${absolute[0]}${absolute.slice(2)}`]
+}
+
+function relativeTo(base: string, vault: string, platform: PathPlatform): string[] {
+  const path = pathModule(platform)
+  const relative = comparableText(path.relative(base, vault), platform)
+  if (relative === "" || path.isAbsolute(relative)) {
+    return []
+  }
+
+  return [relative]
+}
+
+function appearsIn(text: string, form: string, end: RegExp): boolean {
+  let index = text.indexOf(form)
+  while (index !== -1) {
+    const before = text.slice(0, index)
+    const after = text.slice(index + form.length)
+    if (PATH_TOKEN_START.test(before) && end.test(after)) {
+      return true
+    }
+    index = text.indexOf(form, index + 1)
+  }
+
+  return false
+}
+
+function cased(text: string, platform: PathPlatform): string {
+  if (platform === "linux") return text.replace(VARIABLE_REFERENCE, (name: string) => name.toLowerCase())
+  return text.toLowerCase()
+}
+
+function separated(text: string, platform: PathPlatform): string {
+  if (platform === "win32") return text.replaceAll("\\", "/")
+  return text
+}
+
+function withoutFileUrl(text: string, platform: PathPlatform): string {
+  if (platform === "win32") {
+    return text.replace(WINDOWS_FILE_URL_PREFIX, "")
+  }
+
+  return text.replace(FILE_URL_PREFIX, "")
+}
+
+function comparableText(text: string, platform: PathPlatform): string {
+  return separated(cased(withoutFileUrl(text, platform), platform), platform)
+    .replace(/["'`]/g, "")
+    .replace(COMPARABLE_NAMESPACE_UNC, "//")
+    .replace(COMPARABLE_NAMESPACE, "")
+    .replace(COMPARABLE_ADMIN_SHARE, (_share: string, drive: string) => `${drive}:`)
+    .replace(/\/{2,}/g, "/")
+    .replace(/(?<=.)\/$/, "")
+}