@quantiya/codevibe-claude-plugin 2.0.27 → 2.0.29

package/node_modules/type-fest/source/is-literal.d.ts

@@ -1,14 +1,272 @@
-import type {IsStringLiteral} from './is-string-literal.d.ts';
-import type {IsNumericLiteral} from './is-numeric-literal.d.ts';
-import type {IsBooleanLiteral} from './is-boolean-literal.d.ts';
-import type {IsSymbolLiteral} from './is-symbol-literal.d.ts';
+import type {Primitive} from './primitive.d.ts';
+import type {_Numeric} from './numeric.d.ts';
+import type {CollapseLiterals, IfNotAnyOrNever, IsNotFalse, IsPrimitive} from './internal/index.d.ts';
 import type {IsNever} from './is-never.d.ts';
-import type {IfNotAnyOrNever} from './internal/type.d.ts';
-import type {CollapseLiterals, UnwrapBrand} from './internal/object.d.ts';
+import type {TagContainer, UnwrapTagged} from './tagged.d.ts';
+
+/**
+Returns a boolean for whether the given type `T` is the specified `LiteralType`.
+
+@link https://stackoverflow.com/a/52806744/10292952
+
+@example
+```
+type A = LiteralCheck<1, number>;
+//=> true
+
+type B = LiteralCheck<number, number>;
+//=> false
+
+type C = LiteralCheck<1, string>;
+//=> false
+```
+*/
+type LiteralCheck<T, LiteralType extends Primitive> = (
+	IsNever<T> extends false // Must be wider than `never`
+		? [T] extends [LiteralType & infer U] // Remove any branding
+			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
+				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
+					? false
+					: true
+				: false
+			: false
+		: false
+);
+
+/**
+Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
+
+@example
+```
+type A = LiteralChecks<1, Numeric>;
+//=> true
+
+type B = LiteralChecks<1n, Numeric>;
+//=> true
+
+type C = LiteralChecks<bigint, Numeric>;
+//=> false
+```
+*/
+type LiteralChecks<T, LiteralUnionType> = (
+	// Conditional type to force union distribution.
+	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
+	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
+	IsNotFalse<LiteralUnionType extends Primitive
+		? LiteralCheck<T, LiteralUnionType>
+		: never
+	>
+);
+
+/**
+Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed string manipulation functions
+	- constraining strings to be a string literal
+	- type utilities, such as when constructing parsers and ASTs
+
+The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
+
+// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
+function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
+	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
+}
+
+const output = capitalize('hello, world!');
+//=> 'Hello, world!'
+```
+
+@example
+```
+// String types with infinite set of possible values return `false`.
+
+import type {IsStringLiteral} from 'type-fest';
+
+type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
+//=> false
+
+type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
+//=> false
+
+// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
+
+type Length<S extends string, Counter extends never[] = []> =
+	IsStringLiteral<S> extends false
+		? number // return `number` for infinite string types
+		: S extends `${string}${infer Tail}`
+			? Length<Tail, [...Counter, never]>
+			: Counter['length'];
+
+type L1 = Length<Lowercase<string>>;
+//=> number
+
+type L2 = Length<`${number}`>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsStringLiteral<S> = IfNotAnyOrNever<S, {
+	ifNot: _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+export type _IsStringLiteral<S> =
+// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+// and since `{}` extends index signatures, the result becomes `false`.
+	S extends string
+		? {} extends Record<S, never>
+			? false
+			: true
+		: false;
+
+/**
+Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsNumericLiteral, IsStringLiteral} from 'type-fest';
+
+// https://github.com/inocan-group/inferred-types/blob/master/modules/types/src/boolean-logic/operators/EndsWith.ts
+type EndsWith<TValue, TEndsWith extends string> =
+	TValue extends string
+		? IsStringLiteral<TEndsWith> extends true
+			? IsStringLiteral<TValue> extends true
+				? TValue extends `${string}${TEndsWith}`
+					? true
+					: false
+				: boolean
+			: boolean
+		: TValue extends number
+			? IsNumericLiteral<TValue> extends true
+				? EndsWith<`${TValue}`, TEndsWith>
+				: false
+			: false;
+
+function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
+	return `${input}`.endsWith(end) as EndsWith<Input, End>;
+}
+
+endsWith('abc', 'c');
+//=> true
+
+endsWith(123_456, '456');
+//=> true
+
+const end = '123' as string;
+
+endsWith('abc123', end);
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNumericLiteral<T> = LiteralChecks<T, _Numeric>;
+
+/**
+Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsBooleanLiteral} from 'type-fest';
+
+const id = 123;
+
+type GetId<AsString extends boolean> =
+	IsBooleanLiteral<AsString> extends true
+		? AsString extends true
+			? `${typeof id}`
+			: typeof id
+		: number | string;
+
+function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
+	return (options?.asString ? `${id}` : id) as GetId<AsString>;
+}
+
+const numberId = getId();
+//=> 123
+
+const stringId = getId({asString: true});
+//=> '123'
+
+declare const runtimeBoolean: boolean;
+const eitherId = getId({asString: runtimeBoolean});
+//=> string | number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
+
+/**
+Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsSymbolLiteral} from 'type-fest';
+
+type Get<Object_ extends Record<symbol, number>, Key extends keyof Object_> =
+	IsSymbolLiteral<Key> extends true
+		? Object_[Key]
+		: number;
+
+function get<Object_ extends Record<symbol, number>, Key extends keyof Object_>(o: Object_, key: Key) {
+	return o[key] as Get<Object_, Key>;
+}
+
+const symbolLiteral = Symbol('literal');
+let symbolValue = Symbol('value1');
+symbolValue = Symbol('value2');
+
+get({[symbolLiteral]: 1} as const, symbolLiteral);
+//=> 1
+
+get({[symbolValue]: 1} as const, symbolValue);
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
+
+/** Helper type for `IsLiteral`. */
+type IsLiteralUnion<T> =
+	| IsStringLiteral<T>
+	| IsNumericLiteral<T>
+	| IsBooleanLiteral<T>
+	| IsSymbolLiteral<T>;
 
 /**
 Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
 @example
 ```
 import type {IsLiteral} from 'type-fest';
@@ -44,48 +302,16 @@ type I = IsLiteral<symbol>;
 type J = IsLiteral<true>;
 //=> true
 
-type K = IsLiteral<false>;
-//=> true
-
-type L = IsLiteral<boolean>;
+type K = IsLiteral<boolean>;
 //=> false
-
-type M = IsLiteral<1 | 'foo' | false>;
-//=> true
-
-type N = IsLiteral<string | number | symbol>;
-//=> false
-
-type O = IsLiteral<1000n | string | true>;
-//=> boolean
 ```
 
 @category Type Guard
 @category Utilities
 */
-export type IsLiteral<T> = IfNotAnyOrNever<T, {
-	ifNot: _IsLiteral<CollapseLiterals<UnwrapBrand<T>>>;
-	ifAny: false;
-	ifNever: false;
-}>;
-
-type _IsLiteral<T> =
-	| (Extract<T, boolean> extends infer Bools
-		// We can't instantiate `IsBooleanLiteral` with `never`,
-		// because that will add an extraneous `false` to the result if there are no booleans.
-		? IsNever<Bools> extends true
-			? never
-			: IsBooleanLiteral<Bools>
-		: never)
-	| (IsLiteralNonBools<Exclude<T, boolean>>);
-
-type IsLiteralNonBools<T> =
-	T extends number | bigint
-		? IsNumericLiteral<T>
-		: T extends string
-			? IsStringLiteral<T>
-			: T extends symbol
-				? IsSymbolLiteral<T>
-				: false;
+export type IsLiteral<T> =
+	IsPrimitive<T> extends true
+		? IsNotFalse<IsLiteralUnion<T>>
+		: false;
 
 export {};

package/node_modules/type-fest/source/jsonify.d.ts

@@ -25,11 +25,15 @@ type JsonifyList<T extends UnknownArray> = T extends readonly []
 			? JsonValue[]
 			: Array<T[number] extends NotJsonable ? null : Jsonify<UndefinedToNull<T[number]>>>;
 
+type FilterJsonableKeys<T extends object> = {
+	[Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
+}[keyof T];
+
 /**
 JSON serialize objects (not including arrays) and classes.
 */
 type JsonifyObject<T extends object> = {
-	[Key in keyof T as T[Key] extends NotJsonable ? never : Key]: Jsonify<T[Key]>;
+	[Key in keyof Pick<T, FilterJsonableKeys<T>>]: Jsonify<T[Key]>;
 };
 
 /**

package/node_modules/type-fest/source/remove-prefix.d.ts

@@ -1,6 +1,6 @@
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
-import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {Or} from './or.d.ts';
 import type {If} from './if.d.ts';

package/node_modules/type-fest/source/remove-suffix.d.ts

@@ -1,6 +1,6 @@
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
-import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {Or} from './or.d.ts';
 import type {If} from './if.d.ts';

package/node_modules/type-fest/source/shared-union-fields-deep.d.ts

@@ -106,12 +106,11 @@ export type SharedUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOp
 Same as `SharedUnionFieldsDeep`, but accepts only `object`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
 */
 type SharedObjectUnionFieldsDeep<Union, Options extends Required<SharedUnionFieldsDeepOptions>> =
-	// Extract the shared keys from the union. Throughout this type, use `Keys` instead of `keyof Union`
-	// to prevent the mapped type from distributing over the union.
-	keyof Union extends infer Keys extends keyof Union
+	// `keyof Union` can extract the same key in union type, if there is no same key, return never.
+	keyof Union extends infer Keys
 		? IsNever<Keys> extends false
 			? {
-				[Key in Keys]:
+				[Key in keyof Union]:
 				Union[Key] extends NonRecursiveType
 					? Union[Key]
 					// Remove `undefined` from the union to support optional

package/node_modules/type-fest/source/split.d.ts

@@ -1,6 +1,6 @@
 import type {And} from './and.d.ts';
 import type {ApplyDefaultOptions, Not} from './internal/index.d.ts';
-import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
 import type {Or} from './or.d.ts';
 
 /**

package/node_modules/type-fest/source/string-repeat.d.ts

@@ -1,4 +1,4 @@
-import type {IsNumericLiteral} from './is-numeric-literal.d.ts';
+import type {IsNumericLiteral} from './is-literal.d.ts';
 import type {IsNegative} from './numeric.d.ts';
 import type {DigitCharacter} from './characters.d.ts';
 

package/node_modules/type-fest/source/string-to-array.d.ts

@@ -1,6 +1,6 @@
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {IfNotAnyOrNever} from './internal/type.d.ts';
-import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
 import type {Or} from './or.d.ts';
 
 /**

package/node_modules/type-fest/source/tsconfig-json.d.ts

@@ -1266,7 +1266,7 @@ export namespace TsConfigJson {
 		exclude?: string[];
 
 		/**
-		Disable inferring what types should be added based on filenames in a project.
+		Disable infering what types should be added based on filenames in a project.
 		*/
 		disableFilenameBasedTypeAcquisition?: boolean;
 	};

package/node_modules/type-fest/source/typed-array.d.ts

@@ -11,7 +11,6 @@ export type TypedArray =
 	| Uint16Array
 	| Int32Array
 	| Uint32Array
-	| Float16Array
 	| Float32Array
 	| Float64Array
 	| BigInt64Array

package/node_modules/type-fest/source/writable.d.ts

@@ -61,8 +61,8 @@ export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
 				: Simplify<
 					// Pick just the keys that are not writable from the base type.
 					Except<BaseType, Keys>
-					// Make the specified keys writable.
-					& {-readonly [KeyType in keyof BaseType as KeyType extends Keys ? KeyType : never]: BaseType[KeyType]}
+					// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
+					& {-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
 				>;
 
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "2.0.27",
+  "version": "2.0.29",
   "description": "Control Claude Code from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.23",
+    "@quantiya/codevibe-core": "^2.0.25",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/direct-file-delete.d.ts

@@ -1,22 +0,0 @@
-export interface DirectFileDeleteRequest {
-    paths: string[];
-}
-export interface DirectFileDeleteResult {
-    deleted: string[];
-}
-/**
- * Recognize only a closed, deterministic delete request. Anything ambiguous
- * remains on the ordinary planner/implementor path.
- *
- * Supported examples:
- *   Delete only a.txt.
- *   Please delete only `a file.txt` and `b.txt`.
- *   Delete only a.txt. Do not create, modify, or delete any other file.
- */
-export declare function parseDirectFileDeleteRequest(text: string): DirectFileDeleteRequest | null;
-/**
- * Delete only the explicitly named regular files. All targets are validated
- * before the first mutation; each unlink is bound to the captured parent and
- * file incarnation and directory-fsynced by the anchored helper.
- */
-export declare function executeDirectFileDelete(cwd: string, request: DirectFileDeleteRequest): Promise<DirectFileDeleteResult>;